vite 5.0.0-beta.10 → 5.0.0-beta.11

package/dist/node/chunks/{dep-pNoMh5ox.js → dep-HpI8v4GP.js}

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

package/dist/node/chunks/{dep-RTfXXG9P.js → dep-kPX9VBbU.js}

@@ -12220,6 +12220,24 @@ function lookupFile(dir, fileNames) {
         dir = parentDir;
     }
 }
+function isFilePathESM(filePath, packageCache) {
+    if (/\.m[jt]s$/.test(filePath)) {
+        return true;
+    }
+    else if (/\.c[jt]s$/.test(filePath)) {
+        return false;
+    }
+    else {
+        // check package.json for type: "module"
+        try {
+            const pkg = findNearestPackageData(path$o.dirname(filePath), packageCache);
+            return pkg?.data.type === 'module';
+        }
+        catch {
+            return false;
+        }
+    }
+}
 const splitRE = /\r?\n/;
 const range = 2;
 function pad$1(source, n = 2) {
@@ -12694,6 +12712,15 @@ function emptyCssComments(raw) {
 function removeComments(raw) {
     return raw.replace(multilineCommentsRE$1, '').replace(singlelineCommentsRE$1, '');
 }
+function backwardCompatibleWorkerPlugins(plugins) {
+    if (Array.isArray(plugins)) {
+        return plugins;
+    }
+    if (typeof plugins === 'function') {
+        return plugins();
+    }
+    return [];
+}
 function mergeConfigRecursively(defaults, overrides, rootPath) {
     const merged = { ...defaults };
     for (const key in overrides) {
@@ -12721,6 +12748,13 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
             merged[key] = true;
             continue;
         }
+        else if (key === 'plugins' && rootPath === 'worker') {
+            merged[key] = () => [
+                ...backwardCompatibleWorkerPlugins(existing),
+                ...backwardCompatibleWorkerPlugins(value),
+            ];
+            continue;
+        }
         if (Array.isArray(existing) || Array.isArray(value)) {
             merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
             continue;
@@ -15470,12 +15504,16 @@ const viteBuildPublicIdPrefix = '\0vite:asset:public';
  */
 function assetPlugin(config) {
     registerCustomMime();
+    let moduleGraph;
     return {
         name: 'vite:asset',
         buildStart() {
             assetCache.set(config, new Map());
             generatedAssets.set(config, new Map());
         },
+        configureServer(server) {
+            moduleGraph = server.moduleGraph;
+        },
         resolveId(id) {
             if (!config.assetsInclude(cleanUrl(id)) && !urlRE.test(id)) {
                 return;
@@ -15509,8 +15547,15 @@ function assetPlugin(config) {
                 return;
             }
             id = id.replace(urlRE, '$1').replace(unnededFinalQueryCharRE, '');
-            const url = await fileToUrl$1(id, config, this);
-            return `export default ${JSON.stringify(config.command === 'serve' ? `${url}?t=${Date.now()}` : url)}`;
+            let url = await fileToUrl$1(id, config, this);
+            // Inherit HMR timestamp if this asset was invalidated
+            if (moduleGraph) {
+                const mod = moduleGraph.getModuleById(id);
+                if (mod && mod.lastHMRTimestamp > 0) {
+                    url = injectQuery(url, `t=${mod.lastHMRTimestamp}`);
+                }
+            }
+            return `export default ${JSON.stringify(url)}`;
         },
         renderChunk(code, chunk, opts) {
             const s = renderAssetUrlInJS(this, config, chunk, opts, code);
@@ -15631,16 +15676,22 @@ async function fileToBuiltUrl(id, config, pluginContext, skipPublicCheck = false
     const content = await fsp.readFile(file);
     let url;
     if (config.build.lib ||
-        (!file.endsWith('.svg') &&
+        // Don't inline SVG with fragments, as they are meant to be reused
+        (!(file.endsWith('.svg') && id.includes('#')) &&
             !file.endsWith('.html') &&
             content.length < Number(config.build.assetsInlineLimit) &&
             !isGitLfsPlaceholder(content))) {
         if (config.build.lib && isGitLfsPlaceholder(content)) {
             config.logger.warn(colors$1.yellow(`Inlined file ${id} was not downloaded via Git LFS`));
         }
-        const mimeType = lookup(file) ?? 'application/octet-stream';
-        // base64 inlined as a string
-        url = `data:${mimeType};base64,${content.toString('base64')}`;
+        if (file.endsWith('.svg')) {
+            url = svgToDataURL(content);
+        }
+        else {
+            const mimeType = lookup(file) ?? 'application/octet-stream';
+            // base64 inlined as a string
+            url = `data:${mimeType};base64,${content.toString('base64')}`;
+        }
     }
     else {
         // emit as asset
@@ -15670,6 +15721,29 @@ async function urlToBuiltUrl(url, importer, config, pluginContext) {
     // skip public check since we just did it above
     true);
 }
+// Inspired by https://github.com/iconify/iconify/blob/main/packages/utils/src/svg/url.ts
+function svgToDataURL(content) {
+    const stringContent = content.toString();
+    // If the SVG contains some text, any transformation is unsafe, and given that double quotes would then
+    // need to be escaped, the gain to use a data URI would be ridiculous if not negative
+    if (stringContent.includes('<text')) {
+        return `data:image/svg+xml;base64,${content.toString('base64')}`;
+    }
+    else {
+        return ('data:image/svg+xml,' +
+            stringContent
+                .trim()
+                .replaceAll('"', "'")
+                .replaceAll('%', '%25')
+                .replaceAll('#', '%23')
+                .replaceAll('<', '%3c')
+                .replaceAll('>', '%3e')
+                // Spaces are not valid in srcset it has some use cases
+                // it can make the uncompressed URI slightly higher than base64, but will compress way better
+                // https://github.com/vitejs/vite/pull/14643#issuecomment-1766288673
+                .replaceAll(/\s+/g, '%20'));
+    }
+}
 
 function manifestPlugin(config) {
     const manifest = {};
@@ -27829,7 +27903,6 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
             moduleSideEffects: pkg.hasSideEffects(resolved),
         });
     }
-    const ext = path$o.extname(resolved);
     if (!options.ssrOptimizeCheck &&
         (!isInNodeModules$1(resolved) || // linked
             !depsOptimizer || // resolving before listening to the server
@@ -27860,10 +27933,7 @@ function tryNodeResolve(id, importer, options, targetWeb, depsOptimizer, ssr = f
         (!options.ssrOptimizeCheck && !isBuild && ssr) ||
         // Only optimize non-external CJS deps during SSR by default
         (ssr &&
-            !(ext === '.cjs' ||
-                (ext === '.js' &&
-                    findNearestPackageData(path$o.dirname(resolved), options.packageCache)
-                        ?.data.type !== 'module')) &&
+            isFilePathESM(resolved, options.packageCache) &&
             !(include?.includes(pkgId) || include?.includes(id)));
     if (options.ssrOptimizeCheck) {
         return {
@@ -35895,10 +35965,12 @@ const addTypeScriptLoader = (options = {}, loader) => {
       `.${moduleName}rc.yaml`,
       `.${moduleName}rc.yml`,
       `.${moduleName}rc.ts`,
+      `.${moduleName}rc.cts`,
       `.${moduleName}rc.js`,
       `.${moduleName}rc.cjs`,
       `.${moduleName}rc.mjs`,
       `${moduleName}.config.ts`,
+      `${moduleName}.config.cts`,
       `${moduleName}.config.js`,
       `${moduleName}.config.cjs`,
       `${moduleName}.config.mjs`
@@ -35910,7 +35982,8 @@ const addTypeScriptLoader = (options = {}, loader) => {
       '.js': importDefault,
       '.cjs': importDefault,
       '.mjs': importDefault,
-      '.ts': loader
+      '.ts': loader,
+      '.cts': loader
     }
   }
 };
@@ -35922,7 +35995,9 @@ const withTypeScriptLoader = (rcFunc) => {
 
       try {
         // Register TypeScript compiler instance
-        registerer = __require('ts-node').register();
+        registerer = __require('ts-node').register({
+          moduleTypes: { '**/*.cts': 'cjs' }
+        });
 
         return __require(configFile)
       } catch (err) {
@@ -37164,6 +37239,7 @@ function buildHtmlPlugin(config) {
                             tag: 'link',
                             attrs: {
                                 rel: 'stylesheet',
+                                crossorigin: true,
                                 href: toOutputPath(file),
                             },
                         });
@@ -37234,6 +37310,7 @@ function buildHtmlPlugin(config) {
                                 tag: 'link',
                                 attrs: {
                                     rel: 'stylesheet',
+                                    crossorigin: true,
                                     href: toOutputAssetFilePath(cssChunk.fileName),
                                 },
                             },
@@ -37261,7 +37338,11 @@ function buildHtmlPlugin(config) {
                 });
                 // resolve asset url references
                 result = result.replace(assetUrlRE, (_, fileHash, postfix = '') => {
-                    return toOutputAssetFilePath(this.getFileName(fileHash)) + postfix;
+                    const file = this.getFileName(fileHash);
+                    if (chunk) {
+                        chunk.viteMetadata.importedAssets.add(cleanUrl(file));
+                    }
+                    return toOutputAssetFilePath(file) + postfix;
                 });
                 result = result.replace(publicAssetUrlRE, (_, fileHash) => {
                     const publicAssetPath = toOutputPublicAssetFilePath(getPublicAssetFilename(fileHash, config));
@@ -38386,8 +38467,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-s3v9f2KI.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-pNoMh5ox.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-rMlk0HEr.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-HpI8v4GP.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 /**
  * @experimental
@@ -40571,8 +40652,15 @@ function updateModules(file, modules, timestamp, { config, ws, moduleGraph }, af
         updates,
     });
 }
-async function handleFileAddUnlink(file, server) {
+async function handleFileAddUnlink(file, server, isUnlink) {
     const modules = [...(server.moduleGraph.getModulesByFile(file) || [])];
+    if (isUnlink) {
+        for (const deletedMod of modules) {
+            deletedMod.importedModules.forEach((importedMod) => {
+                importedMod.importers.delete(deletedMod);
+            });
+        }
+    }
     modules.push(...getAffectedGlobModules(file, server));
     if (modules.length > 0) {
         updateModules(getShortName(file, server.config.root), unique(modules), Date.now(), server);
@@ -41676,29 +41764,14 @@ function saveEmitWorkerAsset(config, asset) {
     const workerMap = workerCache.get(config.mainConfig || config);
     workerMap.assets.set(fileName, asset);
 }
-// Ensure that only one rollup build is called at the same time to avoid
-// leaking state in plugins between worker builds.
-// TODO: Review if we can parallelize the bundling of workers.
-const workerConfigSemaphore = new WeakMap();
 async function bundleWorkerEntry(config, id, query) {
-    const processing = workerConfigSemaphore.get(config);
-    if (processing) {
-        await processing;
-        return bundleWorkerEntry(config, id, query);
-    }
-    const promise = serialBundleWorkerEntry(config, id, query);
-    workerConfigSemaphore.set(config, promise);
-    promise.then(() => workerConfigSemaphore.delete(config));
-    return promise;
-}
-async function serialBundleWorkerEntry(config, id, query) {
     // bundle the file as entry to support imports
     const { rollup } = await import('rollup');
     const { plugins, rollupOptions, format } = config.worker;
     const bundle = await rollup({
         ...rollupOptions,
         input: cleanUrl(id),
-        plugins,
+        plugins: await plugins(),
         onwarn(warning, warn) {
             onRollupWarning(warning, warn, config);
         },
@@ -54161,8 +54234,6 @@ async function resolveHttpServer({ proxy }, app, httpsOptions) {
 async function resolveHttpsConfig(https) {
     if (!https)
         return undefined;
-    if (!isObject$1(https))
-        return {};
     const [ca, cert, key, pfx] = await Promise.all([
         readFileIfExists(https.ca),
         readFileIfExists(https.cert),
@@ -54790,12 +54861,20 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
     const declaredConst = new Set();
     // hoist at the start of the file, after the hashbang
     const hoistIndex = code.match(hashbangRE)?.[0].length ?? 0;
-    function defineImport(source) {
+    function defineImport(source, metadata) {
         deps.add(source);
         const importId = `__vite_ssr_import_${uid++}__`;
+        // Reduce metadata to undefined if it's all default values
+        if (metadata &&
+            metadata.isExportAll !== true &&
+            (metadata.namedImportSpecifiers == null ||
+                metadata.namedImportSpecifiers.length === 0)) {
+            metadata = undefined;
+        }
+        const metadataStr = metadata ? `, ${JSON.stringify(metadata)}` : '';
         // There will be an error if the module is called before it is imported,
         // so the module import statement is hoisted to the top
-        s.appendLeft(hoistIndex, `const ${importId} = await ${ssrImportKey}(${JSON.stringify(source)});\n`);
+        s.appendLeft(hoistIndex, `const ${importId} = await ${ssrImportKey}(${JSON.stringify(source)}${metadataStr});\n`);
         return importId;
     }
     function defineExport(position, name, local = name) {
@@ -54808,7 +54887,11 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
         // import { baz } from 'foo' --> baz -> __import_foo__.baz
         // import * as ok from 'foo' --> ok -> __import_foo__
         if (node.type === 'ImportDeclaration') {
-            const importId = defineImport(node.source.value);
+            const importId = defineImport(node.source.value, {
+                namedImportSpecifiers: node.specifiers
+                    .map((s) => s.type === 'ImportSpecifier' && s.imported.name)
+                    .filter(Boolean),
+            });
             s.remove(node.start, node.end);
             for (const spec of node.specifiers) {
                 if (spec.type === 'ImportSpecifier') {
@@ -54849,7 +54932,9 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
                 s.remove(node.start, node.end);
                 if (node.source) {
                     // export { foo, bar } from './foo'
-                    const importId = defineImport(node.source.value);
+                    const importId = defineImport(node.source.value, {
+                        namedImportSpecifiers: node.specifiers.map((s) => s.local.name),
+                    });
                     // hoist re-exports near the defined import so they are immediately exported
                     for (const spec of node.specifiers) {
                         defineExport(hoistIndex, spec.exported.name, `${importId}.${spec.local.name}`);
@@ -54887,7 +54972,9 @@ async function ssrTransformScript(code, inMap, url, originalCode) {
         // export * from './foo'
         if (node.type === 'ExportAllDeclaration') {
             s.remove(node.start, node.end);
-            const importId = defineImport(node.source.value);
+            const importId = defineImport(node.source.value, {
+                isExportAll: true,
+            });
             // hoist re-exports near the defined import so they are immediately exported
             if (node.exported) {
                 defineExport(hoistIndex, node.exported.name, `${importId}`);
@@ -55348,14 +55435,16 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         isProduction,
         root,
         ssrConfig: ssr,
+        legacyProxySsrExternalModules: server.config.legacy?.proxySsrExternalModules,
+        packageCache: server.config.packageCache,
     };
     // Since dynamic imports can happen in parallel, we need to
     // account for multiple pending deps and duplicate imports.
     const pendingDeps = [];
-    const ssrImport = async (dep) => {
+    const ssrImport = async (dep, metadata) => {
         try {
             if (dep[0] !== '.' && dep[0] !== '/') {
-                return await nodeImport(dep, mod.file, resolveOptions);
+                return await nodeImport(dep, mod.file, resolveOptions, metadata);
             }
             // convert to rollup URL because `pendingImports`, `moduleGraph.urlToModuleMap` requires that
             dep = unwrapId(dep);
@@ -55388,7 +55477,7 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         if (dep[0] === '.') {
             dep = path$o.posix.resolve(path$o.dirname(url), dep);
         }
-        return ssrImport(dep);
+        return ssrImport(dep, { isDynamicImport: true });
     };
     function ssrExportAll(sourceModule) {
         for (const key in sourceModule) {
@@ -55439,9 +55528,10 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
     return Object.freeze(ssrModule);
 }
 // In node@12+ we can use dynamic import to load CJS and ESM
-async function nodeImport(id, importer, resolveOptions) {
+async function nodeImport(id, importer, resolveOptions, metadata) {
     let url;
-    if (id.startsWith('data:') || isBuiltin(id)) {
+    const isRuntimeHandled = id.startsWith('data:') || isBuiltin(id);
+    if (isRuntimeHandled) {
         url = id;
     }
     else {
@@ -55454,7 +55544,16 @@ async function nodeImport(id, importer, resolveOptions) {
         url = pathToFileURL(resolved.id).toString();
     }
     const mod = await import(url);
-    return proxyESM(mod);
+    if (resolveOptions.legacyProxySsrExternalModules) {
+        return proxyESM(mod);
+    }
+    else if (isRuntimeHandled) {
+        return mod;
+    }
+    else {
+        analyzeImportedModDifference(mod, url, id, metadata, resolveOptions.packageCache);
+        return proxyGuardOnlyEsm(mod, id);
+    }
 }
 // rollup-style default import interop for cjs
 function proxyESM(mod) {
@@ -55479,6 +55578,49 @@ function proxyESM(mod) {
 function isPrimitive(value) {
     return !value || (typeof value !== 'object' && typeof value !== 'function');
 }
+/**
+ * Vite converts `import { } from 'foo'` to `const _ = __vite_ssr_import__('foo')`.
+ * Top-level imports and dynamic imports work slightly differently in Node.js.
+ * This function normalizes the differences so it matches prod behaviour.
+ */
+function analyzeImportedModDifference(mod, filePath, rawId, metadata, packageCache) {
+    // No normalization needed if the user already dynamic imports this module
+    if (metadata?.isDynamicImport)
+        return;
+    // If file path is ESM, everything should be fine
+    if (isFilePathESM(filePath, packageCache))
+        return;
+    // For non-ESM, named imports is done via static analysis with cjs-module-lexer in Node.js.
+    // If the user named imports a specifier that can't be analyzed, error.
+    if (metadata?.namedImportSpecifiers?.length) {
+        const missingBindings = metadata.namedImportSpecifiers.filter((s) => !(s in mod));
+        if (missingBindings.length) {
+            const lastBinding = missingBindings[missingBindings.length - 1];
+            // Copied from Node.js
+            throw new SyntaxError(`\
+Named export '${lastBinding}' not found. The requested module '${rawId}' is a CommonJS module, which may not support all module.exports as named exports.
+CommonJS modules can always be imported via the default export, for example using:
+
+import pkg from '${rawId}';
+const {${missingBindings.join(', ')}} = pkg;
+`);
+        }
+    }
+}
+/**
+ * Guard invalid named exports only, similar to how Node.js errors for top-level imports.
+ * But since we transform as dynamic imports, we need to emulate the error manually.
+ */
+function proxyGuardOnlyEsm(mod, rawId) {
+    return new Proxy(mod, {
+        get(mod, prop) {
+            if (prop !== 'then' && !(prop in mod)) {
+                throw new SyntaxError(`The requested module '${rawId}' does not provide an export named '${prop.toString()}'`);
+            }
+            return mod[prop];
+        },
+    });
+}
 
 var isWsl$2 = {exports: {}};
 
@@ -64770,9 +64912,9 @@ async function _createServer(inlineConfig = {}, options) {
             }
         }
     };
-    const onFileAddUnlink = async (file) => {
+    const onFileAddUnlink = async (file, isUnlink) => {
         file = normalizePath$3(file);
-        await handleFileAddUnlink(file, server);
+        await handleFileAddUnlink(file, server, isUnlink);
         await onHMRUpdate(file, true);
     };
     watcher.on('change', async (file) => {
@@ -64781,8 +64923,8 @@ async function _createServer(inlineConfig = {}, options) {
         moduleGraph.onFileChange(file);
         await onHMRUpdate(file, false);
     });
-    watcher.on('add', onFileAddUnlink);
-    watcher.on('unlink', onFileAddUnlink);
+    watcher.on('add', (file) => onFileAddUnlink(file, false));
+    watcher.on('unlink', (file) => onFileAddUnlink(file, true));
     ws.on('vite:invalidate', async ({ path, message }) => {
         const mod = moduleGraph.urlToModuleMap.get(path);
         if (mod && mod.isSelfAccepting && mod.lastHMRTimestamp > 0) {
@@ -65336,10 +65478,6 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
             return p.apply === command;
         }
     };
-    // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
-    // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
-    // So we need to separate the worker plugin from the plugin that vite needs to run.
-    const rawWorkerUserPlugins = (await asyncFlatten(config.worker?.plugins || [])).filter(filterPlugin);
     // resolve plugins
     const rawUserPlugins = (await asyncFlatten(config.plugins || [])).filter(filterPlugin);
     const [prePlugins, normalPlugins, postPlugins] = sortUserPlugins(rawUserPlugins);
@@ -65489,24 +65627,48 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
     const middlewareMode = config?.server?.middlewareMode;
     const optimizeDeps = config.optimizeDeps || {};
     const BASE_URL = resolvedBase;
-    // resolve worker
-    let workerConfig = mergeConfig({}, config);
-    const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins(rawWorkerUserPlugins);
-    // run config hooks
-    const workerUserPlugins = [
-        ...workerPrePlugins,
-        ...workerNormalPlugins,
-        ...workerPostPlugins,
-    ];
-    workerConfig = await runConfigHook(workerConfig, workerUserPlugins, configEnv);
+    let resolved;
+    let createUserWorkerPlugins = config.worker?.plugins;
+    if (Array.isArray(createUserWorkerPlugins)) {
+        // @ts-expect-error backward compatibility
+        createUserWorkerPlugins = () => config.worker?.plugins;
+        logger.warn(colors$1.yellow(`worker.plugins is now a function that returns an array of plugins. ` +
+            `Please update your Vite config accordingly.\n`));
+    }
+    const createWorkerPlugins = async function () {
+        // Some plugins that aren't intended to work in the bundling of workers (doing post-processing at build time for example).
+        // And Plugins may also have cached that could be corrupted by being used in these extra rollup calls.
+        // So we need to separate the worker plugin from the plugin that vite needs to run.
+        const rawWorkerUserPlugins = (await asyncFlatten(createUserWorkerPlugins?.() || [])).filter(filterPlugin);
+        // resolve worker
+        let workerConfig = mergeConfig({}, config);
+        const [workerPrePlugins, workerNormalPlugins, workerPostPlugins] = sortUserPlugins(rawWorkerUserPlugins);
+        // run config hooks
+        const workerUserPlugins = [
+            ...workerPrePlugins,
+            ...workerNormalPlugins,
+            ...workerPostPlugins,
+        ];
+        workerConfig = await runConfigHook(workerConfig, workerUserPlugins, configEnv);
+        const workerResolved = {
+            ...workerConfig,
+            ...resolved,
+            isWorker: true,
+            mainConfig: resolved,
+        };
+        const resolvedWorkerPlugins = await resolvePlugins(workerResolved, workerPrePlugins, workerNormalPlugins, workerPostPlugins);
+        // run configResolved hooks
+        createPluginHookUtils(resolvedWorkerPlugins)
+            .getSortedPluginHooks('configResolved')
+            .map((hook) => hook(workerResolved));
+        return resolvedWorkerPlugins;
+    };
     const resolvedWorkerOptions = {
-        format: workerConfig.worker?.format || 'iife',
-        plugins: [],
-        rollupOptions: workerConfig.worker?.rollupOptions || {},
-        getSortedPlugins: undefined,
-        getSortedPluginHooks: undefined,
+        format: config.worker?.format || 'iife',
+        plugins: createWorkerPlugins,
+        rollupOptions: config.worker?.rollupOptions || {},
     };
-    const resolvedConfig = {
+    resolved = {
         configFile: configFile ? normalizePath$3(configFile) : undefined,
         configFileDependencies: configFileDependencies.map((name) => normalizePath$3(path$o.resolve(name))),
         inlineConfig,
@@ -65565,29 +65727,16 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         getSortedPlugins: undefined,
         getSortedPluginHooks: undefined,
     };
-    const resolved = {
+    resolved = {
         ...config,
-        ...resolvedConfig,
+        ...resolved,
     };
     resolved.plugins = await resolvePlugins(resolved, prePlugins, normalPlugins, postPlugins);
     Object.assign(resolved, createPluginHookUtils(resolved.plugins));
-    const workerResolved = {
-        ...workerConfig,
-        ...resolvedConfig,
-        isWorker: true,
-        mainConfig: resolved,
-    };
-    resolvedConfig.worker.plugins = await resolvePlugins(workerResolved, workerPrePlugins, workerNormalPlugins, workerPostPlugins);
-    Object.assign(resolvedConfig.worker, createPluginHookUtils(resolvedConfig.worker.plugins));
     // call configResolved hooks
-    await Promise.all([
-        ...resolved
-            .getSortedPluginHooks('configResolved')
-            .map((hook) => hook(resolved)),
-        ...resolvedConfig.worker
-            .getSortedPluginHooks('configResolved')
-            .map((hook) => hook(workerResolved)),
-    ]);
+    await Promise.all(resolved
+        .getSortedPluginHooks('configResolved')
+        .map((hook) => hook(resolved)));
     // validate config
     if (middlewareMode === 'ssr') {
         logger.warn(colors$1.yellow(`Setting server.middlewareMode to 'ssr' is deprecated, set server.middlewareMode to \`true\`${config.appType === 'custom' ? '' : ` and appType to 'custom'`} instead`));
@@ -65600,7 +65749,7 @@ async function resolveConfig(inlineConfig, command, defaultMode = 'development',
         plugins: resolved.plugins.map((p) => p.name),
         worker: {
             ...resolved.worker,
-            plugins: resolved.worker.plugins.map((p) => p.name),
+            plugins: `() => plugins`,
         },
     });
     if (config.build?.terserOptions && config.build.minify !== 'terser') {
@@ -65702,22 +65851,7 @@ async function loadConfigFromFile(configEnv, configFile, configRoot = process.cw
         debug?.('no config file found.');
         return null;
     }
-    let isESM = false;
-    if (/\.m[jt]s$/.test(resolvedPath)) {
-        isESM = true;
-    }
-    else if (/\.c[jt]s$/.test(resolvedPath)) {
-        isESM = false;
-    }
-    else {
-        // check package.json for type: "module" and set `isESM` to true
-        try {
-            const pkg = lookupFile(configRoot, ['package.json']);
-            isESM =
-                !!pkg && JSON.parse(fs$l.readFileSync(pkg, 'utf-8')).type === 'module';
-        }
-        catch (e) { }
-    }
+    const isESM = isFilePathESM(resolvedPath);
     try {
         const bundled = await bundleConfigFile(resolvedPath, isESM);
         const userConfig = await loadConfigFromBundledFile(resolvedPath, bundled.code, isESM);
@@ -65782,14 +65916,6 @@ async function bundleConfigFile(fileName, isESM) {
                             isRequire,
                         }, false)?.id;
                     };
-                    const isESMFile = (id) => {
-                        if (id.endsWith('.mjs'))
-                            return true;
-                        if (id.endsWith('.cjs'))
-                            return false;
-                        const nearestPackageJson = findNearestPackageData(path$o.dirname(id), packageCache);
-                        return (!!nearestPackageJson && nearestPackageJson.data.type === 'module');
-                    };
                     // externalize bare imports
                     build.onResolve({ filter: /^[^.].*/ }, async ({ path: id, importer, kind }) => {
                         if (kind === 'entry-point' ||
@@ -65824,7 +65950,9 @@ async function bundleConfigFile(fileName, isESM) {
                         if (idFsPath && isImport) {
                             idFsPath = pathToFileURL(idFsPath).href;
                         }
-                        if (idFsPath && !isImport && isESMFile(idFsPath)) {
+                        if (idFsPath &&
+                            !isImport &&
+                            isFilePathESM(idFsPath, packageCache)) {
                             throw new Error(`${JSON.stringify(id)} resolved to an ESM file. ESM file cannot be loaded by \`require\`. See http://vitejs.dev/guide/troubleshooting.html#this-package-is-esm-only for more details.`);
                         }
                         return {

package/dist/node/chunks/{dep-s3v9f2KI.js → dep-rMlk0HEr.js}

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

package/dist/node/cli.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { x as colors, k as createLogger, r as resolveConfig } from './chunks/dep-RTfXXG9P.js';
+import { x as colors, k as createLogger, r as resolveConfig } from './chunks/dep-kPX9VBbU.js';
 import { VERSION } from './constants.js';
 import 'node:fs/promises';
 import 'node:url';
@@ -751,7 +751,6 @@ cli
     .alias('dev') // alias to align with the script name
     .option('--host [host]', `[string] specify hostname`, { type: [convertHost] })
     .option('--port <port>', `[number] specify port`)
-    .option('--https', `[boolean] use TLS + HTTP/2`)
     .option('--open [path]', `[boolean | string] open browser on startup`)
     .option('--cors', `[boolean] enable CORS`)
     .option('--strictPort', `[boolean] exit if specified port is already in use`)
@@ -760,7 +759,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-RTfXXG9P.js').then(function (n) { return n.C; });
+    const { createServer } = await import('./chunks/dep-kPX9VBbU.js').then(function (n) { return n.C; });
     try {
         const server = await createServer({
             root,
@@ -841,7 +840,7 @@ cli
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { build } = await import('./chunks/dep-RTfXXG9P.js').then(function (n) { return n.B; });
+    const { build } = await import('./chunks/dep-kPX9VBbU.js').then(function (n) { return n.B; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -869,7 +868,7 @@ cli
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { optimizeDeps } = await import('./chunks/dep-RTfXXG9P.js').then(function (n) { return n.A; });
+    const { optimizeDeps } = await import('./chunks/dep-kPX9VBbU.js').then(function (n) { return n.A; });
     try {
         const config = await resolveConfig({
             root,
@@ -891,12 +890,11 @@ cli
     .option('--host [host]', `[string] specify hostname`, { type: [convertHost] })
     .option('--port <port>', `[number] specify port`)
     .option('--strictPort', `[boolean] exit if specified port is already in use`)
-    .option('--https', `[boolean] use TLS + HTTP/2`)
     .option('--open [path]', `[boolean | string] open browser on startup`)
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-RTfXXG9P.js').then(function (n) { return n.D; });
+    const { preview } = await import('./chunks/dep-kPX9VBbU.js').then(function (n) { return n.D; });
     try {
         const server = await preview({
             root,
@@ -911,7 +909,6 @@ cli
                 port: options.port,
                 strictPort: options.strictPort,
                 host: options.host,
-                https: options.https,
                 open: options.open,
             },
         });

package/dist/node/index.d.ts

@@ -639,7 +639,7 @@ interface CommonServerOptions {
      * Enable TLS + HTTP/2.
      * Note: this downgrades to TLS only when the proxy option is also used.
      */
-    https?: boolean | HttpsServerOptions;
+    https?: HttpsServerOptions;
     /**
      * Open browser window on startup
      */
@@ -3095,9 +3095,11 @@ interface UserConfig {
          */
         format?: 'es' | 'iife';
         /**
-         * Vite plugins that apply to worker bundle
+         * Vite plugins that apply to worker bundle. The plugins retured by this function
+         * should be new instances every time it is called, because they are used for each
+         * rollup worker bundling process.
          */
-        plugins?: PluginOption[];
+        plugins?: () => PluginOption[];
         /**
          * Rollup options to build worker bundle
          */
@@ -3142,10 +3144,21 @@ interface ExperimentalOptions {
     skipSsrTransform?: boolean;
 }
 interface LegacyOptions {
+    /**
+     * In Vite 4, SSR-externalized modules (modules not bundled and loaded by Node.js at runtime)
+     * are implicitly proxied in dev to automatically handle `default` and `__esModule` access.
+     * However, this does not correctly reflect how it works in the Node.js runtime, causing
+     * inconsistencies between dev and prod.
+     *
+     * In Vite 5, the proxy is removed so dev and prod are consistent, but if you still require
+     * the old behaviour, you can enable this option. If so, please leave your feedback at
+     * https:
+     */
+    proxySsrExternalModules?: boolean;
 }
-interface ResolvedWorkerOptions extends PluginHookUtils {
+interface ResolvedWorkerOptions {
     format: 'es' | 'iife';
-    plugins: Plugin[];
+    plugins: () => Promise<Plugin[]>;
     rollupOptions: RollupOptions;
 }
 interface InlineConfig extends UserConfig {

package/dist/node/index.js

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

package/dist/node-cjs/publicUtils.cjs

@@ -3488,6 +3488,15 @@ function arraify(target) {
     return Array.isArray(target) ? target : [target];
 }
 path$3.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('node-cjs/publicUtils.cjs', document.baseURI).href))));
+function backwardCompatibleWorkerPlugins(plugins) {
+    if (Array.isArray(plugins)) {
+        return plugins;
+    }
+    if (typeof plugins === 'function') {
+        return plugins();
+    }
+    return [];
+}
 function mergeConfigRecursively(defaults, overrides, rootPath) {
     const merged = { ...defaults };
     for (const key in overrides) {
@@ -3515,6 +3524,13 @@ function mergeConfigRecursively(defaults, overrides, rootPath) {
             merged[key] = true;
             continue;
         }
+        else if (key === 'plugins' && rootPath === 'worker') {
+            merged[key] = () => [
+                ...backwardCompatibleWorkerPlugins(existing),
+                ...backwardCompatibleWorkerPlugins(value),
+            ];
+            continue;
+        }
         if (Array.isArray(existing) || Array.isArray(value)) {
             merged[key] = [...arraify(existing ?? []), ...arraify(value ?? [])];
             continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "5.0.0-beta.10",
+  "version": "5.0.0-beta.11",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",