@sveltejs/vite-plugin-svelte 5.1.0 → 6.0.0-next.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sveltejs/vite-plugin-svelte",
-  "version": "5.1.0",
+  "version": "6.0.0-next.1",
   "license": "MIT",
   "author": "dominikg",
   "files": [
@@ -11,14 +11,12 @@
   "types": "types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/index.d.ts",
-        "default": "./src/index.js"
-      }
+      "types": "./types/index.d.ts",
+      "default": "./src/index.js"
     }
   },
   "engines": {
-    "node": "^18.0.0 || ^20.0.0 || >=22"
+    "node": "^20.19 || ^22.12 || >=24"
   },
   "repository": {
     "type": "git",
@@ -36,22 +34,22 @@
   },
   "homepage": "https://github.com/sveltejs/vite-plugin-svelte#readme",
   "dependencies": {
-    "@sveltejs/vite-plugin-svelte-inspector": "^4.0.1",
+    "@sveltejs/vite-plugin-svelte-inspector": "^5.0.0-next.0",
     "debug": "^4.4.1",
     "deepmerge": "^4.3.1",
     "kleur": "^4.1.5",
     "magic-string": "^0.30.17",
-    "vitefu": "^1.0.6"
+    "vitefu": "^1.0.7"
   },
   "peerDependencies": {
     "svelte": "^5.0.0",
-    "vite": "^6.0.0"
+    "vite": "^6.3.0 || ^7.0.0-beta.0"
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "sass": "^1.89.0",
-    "svelte": "^5.33.3",
-    "vite": "^6.3.5"
+    "sass": "^1.89.2",
+    "svelte": "^5.34.7",
+    "vite": "^7.0.0-beta.2"
   },
   "scripts": {
     "check:publint": "publint --strict",

package/src/index.js

@@ -4,7 +4,12 @@ import { svelteInspector } from '@sveltejs/vite-plugin-svelte-inspector';
 import { handleHotUpdate } from './handle-hot-update.js';
 import { log, logCompilerWarnings } from './utils/log.js';
 import { createCompileSvelte } from './utils/compile.js';
-import { buildIdParser, buildModuleIdParser } from './utils/id.js';
+import {
+	buildIdFilter,
+	buildIdParser,
+	buildModuleIdFilter,
+	buildModuleIdParser
+} from './utils/id.js';
 import {
 	buildExtraViteConfig,
 	validateInlineOptions,
@@ -20,6 +25,10 @@ import { saveSvelteMetadata } from './utils/optimizer.js';
 import { VitePluginSvelteCache } from './utils/vite-plugin-svelte-cache.js';
 import { loadRaw } from './utils/load-raw.js';
 import * as svelteCompiler from 'svelte/compiler';
+import { SVELTE_VIRTUAL_STYLE_ID_REGEX } from './utils/constants.js';
+import * as vite from 'vite';
+// @ts-expect-error rolldownVersion
+const { version: viteVersion, rolldownVersion } = vite;
 
 /**
  * @param {Partial<import('./public.d.ts').Options>} [inlineOptions]
@@ -29,6 +38,16 @@ export function svelte(inlineOptions) {
 	if (process.env.DEBUG != null) {
 		log.setLevel('debug');
 	}
+	if (rolldownVersion) {
+		log.warn.once(
+			`!!! Support for rolldown-vite in vite-plugin-svelte is experimental (rolldown: ${rolldownVersion}, vite: ${viteVersion}) !!!
+			See https://github.com/sveltejs/vite-plugin-svelte/issues/1143 for a list of known issues and to report feedback.`.replace(
+				/\t+/g,
+				'\t'
+			)
+		);
+	}
+
 	validateInlineOptions(inlineOptions);
 	const cache = new VitePluginSvelteCache();
 	// updated in configResolved hook
@@ -42,67 +61,74 @@ export function svelte(inlineOptions) {
 	let viteConfig;
 	/** @type {import('./types/compile.d.ts').CompileSvelte} */
 	let compileSvelte;
-	/** @type {import('./types/plugin-api.d.ts').PluginAPI} */
-	const api = {};
-	/** @type {import('vite').Plugin[]} */
-	const plugins = [
-		{
-			name: 'vite-plugin-svelte',
-			// make sure our resolver runs before vite internal resolver to resolve svelte field correctly
-			enforce: 'pre',
-			api,
-			async config(config, configEnv) {
-				// setup logger
-				if (process.env.DEBUG) {
-					log.setLevel('debug');
-				} else if (config.logLevel) {
-					log.setLevel(config.logLevel);
-				}
-				// @ts-expect-error temporarily lend the options variable until fixed in configResolved
-				options = await preResolveOptions(inlineOptions, config, configEnv);
-				// extra vite config
-				const extraViteConfig = await buildExtraViteConfig(options, config);
-				log.debug('additional vite config', extraViteConfig, 'config');
-				return extraViteConfig;
-			},
-
-			configEnvironment(name, config, opts) {
-				ensureConfigEnvironmentMainFields(name, config, opts);
-				// @ts-expect-error the function above should make `resolve.mainFields` non-nullable
-				config.resolve.mainFields.unshift('svelte');
-
-				ensureConfigEnvironmentConditions(name, config, opts);
-				// @ts-expect-error the function above should make `resolve.conditions` non-nullable
-				config.resolve.conditions.push('svelte');
-			},
-
-			async configResolved(config) {
-				options = resolveOptions(options, config, cache);
-				patchResolvedViteConfig(config, options);
-				requestParser = buildIdParser(options);
-				compileSvelte = createCompileSvelte();
-				viteConfig = config;
-				// TODO deep clone to avoid mutability from outside?
-				api.options = options;
-				log.debug('resolved options', options, 'config');
-			},
-
-			async buildStart() {
-				if (!options.prebundleSvelteLibraries) return;
-				const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
-				if (isSvelteMetadataChanged) {
-					// Force Vite to optimize again. Although we mutate the config here, it works because
-					// Vite's optimizer runs after `buildStart()`.
-					viteConfig.optimizeDeps.force = true;
-				}
-			},
 
-			configureServer(server) {
-				options.server = server;
-				setupWatchers(options, cache, requestParser);
-			},
+	/** @type {import('vite').Plugin} */
+	const compilePlugin = {
+		name: 'vite-plugin-svelte',
+		// make sure our resolver runs before vite internal resolver to resolve svelte field correctly
+		enforce: 'pre',
+		/** @type {import('./types/plugin-api.d.ts').PluginAPI} */
+		api: {},
+		async config(config, configEnv) {
+			// setup logger
+			if (process.env.DEBUG) {
+				log.setLevel('debug');
+			} else if (config.logLevel) {
+				log.setLevel(config.logLevel);
+			}
+			// @ts-expect-error temporarily lend the options variable until fixed in configResolved
+			options = await preResolveOptions(inlineOptions, config, configEnv);
+			// extra vite config
+			const extraViteConfig = await buildExtraViteConfig(options, config);
+			log.debug('additional vite config', extraViteConfig, 'config');
+			return extraViteConfig;
+		},
+
+		configEnvironment(name, config, opts) {
+			ensureConfigEnvironmentMainFields(name, config, opts);
+			// @ts-expect-error the function above should make `resolve.mainFields` non-nullable
+			config.resolve.mainFields.unshift('svelte');
+
+			ensureConfigEnvironmentConditions(name, config, opts);
+			// @ts-expect-error the function above should make `resolve.conditions` non-nullable
+			config.resolve.conditions.push('svelte');
+		},
+
+		async configResolved(config) {
+			options = resolveOptions(options, config, cache);
+			patchResolvedViteConfig(config, options);
+			const filter = buildIdFilter(options);
+			//@ts-expect-error transform defined below but filter not in type
+			compilePlugin.transform.filter = filter;
+			//@ts-expect-error load defined below but filter not in type
+			compilePlugin.load.filter = filter;
+
+			requestParser = buildIdParser(options);
+			compileSvelte = createCompileSvelte();
+			viteConfig = config;
+			// TODO deep clone to avoid mutability from outside?
+			compilePlugin.api.options = options;
+			log.debug('resolved options', options, 'config');
+			log.debug('filters', filter, 'config');
+		},
+
+		async buildStart() {
+			if (!options.prebundleSvelteLibraries) return;
+			const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
+			if (isSvelteMetadataChanged) {
+				// Force Vite to optimize again. Although we mutate the config here, it works because
+				// Vite's optimizer runs after `buildStart()`.
+				viteConfig.optimizeDeps.force = true;
+			}
+		},
 
-			async load(id, opts) {
+		configureServer(server) {
+			options.server = server;
+			setupWatchers(options, cache, requestParser);
+		},
+
+		load: {
+			async handler(id, opts) {
 				const ssr = !!opts?.ssr;
 				const svelteRequest = requestParser(id, !!ssr);
 				if (svelteRequest) {
@@ -127,6 +153,8 @@ export function svelte(inlineOptions) {
 									css.meta.vite ??= {};
 									css.meta.vite.cssScopeTo = [svelteRequest.filename, 'default'];
 								}
+								css.moduleType = 'css';
+
 								return css;
 							}
 						}
@@ -137,30 +165,23 @@ export function svelte(inlineOptions) {
 						}
 					}
 				}
-			},
+			}
+		},
 
-			async resolveId(importee, importer, opts) {
-				const ssr = !!opts?.ssr;
-				const svelteRequest = requestParser(importee, ssr);
-				if (svelteRequest?.query.svelte) {
-					if (
-						svelteRequest.query.type === 'style' &&
-						!svelteRequest.raw &&
-						!svelteRequest.query.inline
-					) {
-						// return cssId with root prefix so postcss pipeline of vite finds the directory correctly
-						// see https://github.com/sveltejs/vite-plugin-svelte/issues/14
-						log.debug(
-							`resolveId resolved virtual css module ${svelteRequest.cssId}`,
-							undefined,
-							'resolve'
-						);
-						return svelteRequest.cssId;
-					}
-				}
-			},
+		resolveId: {
+			// we don't use our generic filter here but a reduced one that only matches our virtual css
+			filter: { id: SVELTE_VIRTUAL_STYLE_ID_REGEX },
+			handler(id) {
+				// return cssId with root prefix so postcss pipeline of vite finds the directory correctly
+				// see https://github.com/sveltejs/vite-plugin-svelte/issues/14
+				log.debug(`resolveId resolved virtual css module ${id}`, undefined, 'resolve');
+				// TODO: do we have to repeat the dance for constructing the virtual id here? our transform added it that way
+				return id;
+			}
+		},
 
-			async transform(code, id, opts) {
+		transform: {
+			async handler(code, id, opts) {
 				const ssr = !!opts?.ssr;
 				const svelteRequest = requestParser(id, ssr);
 				if (!svelteRequest || svelteRequest.query.type === 'style' || svelteRequest.raw) {
@@ -188,34 +209,41 @@ export function svelte(inlineOptions) {
 				}
 				return {
 					...compileData.compiled.js,
+					moduleType: 'js',
 					meta: {
 						vite: {
 							lang: compileData.lang
 						}
 					}
 				};
-			},
+			}
+		},
 
-			handleHotUpdate(ctx) {
-				if (!options.compilerOptions.hmr || !options.emitCss) {
-					return;
-				}
-				const svelteRequest = requestParser(ctx.file, false, ctx.timestamp);
-				if (svelteRequest) {
-					return handleHotUpdate(compileSvelte, ctx, svelteRequest, cache, options);
-				}
-			},
-			async buildEnd() {
-				await options.stats?.finishAll();
+		handleHotUpdate(ctx) {
+			if (!options.compilerOptions.hmr || !options.emitCss) {
+				return;
+			}
+			const svelteRequest = requestParser(ctx.file, false, ctx.timestamp);
+			if (svelteRequest) {
+				return handleHotUpdate(compileSvelte, ctx, svelteRequest, cache, options);
 			}
 		},
-		{
-			name: 'vite-plugin-svelte-module',
-			enforce: 'post',
-			async configResolved() {
-				moduleRequestParser = buildModuleIdParser(options);
-			},
-			async transform(code, id, opts) {
+		async buildEnd() {
+			await options.stats?.finishAll();
+		}
+	};
+
+	/** @type {import('vite').Plugin} */
+	const moduleCompilePlugin = {
+		name: 'vite-plugin-svelte-module',
+		enforce: 'post',
+		async configResolved() {
+			//@ts-expect-error transform defined below but filter not in type
+			moduleCompilePlugin.transform.filter = buildModuleIdFilter(options);
+			moduleRequestParser = buildModuleIdParser(options);
+		},
+		transform: {
+			async handler(code, id, opts) {
 				const ssr = !!opts?.ssr;
 				const moduleRequest = moduleRequestParser(id, ssr);
 				if (!moduleRequest) {
@@ -233,9 +261,11 @@ export function svelte(inlineOptions) {
 					throw toRollupError(e, options);
 				}
 			}
-		},
-		svelteInspector()
-	];
+		}
+	};
+
+	/** @type {import('vite').Plugin[]} */
+	const plugins = [compilePlugin, moduleCompilePlugin, svelteInspector()];
 	return plugins;
 }
 

package/src/preprocess.js

@@ -1,7 +1,16 @@
 import process from 'node:process';
-import { isCSSRequest, preprocessCSS, resolveConfig, transformWithEsbuild } from 'vite';
+import * as vite from 'vite';
 import { mapToRelative, removeLangSuffix } from './utils/sourcemaps.js';
-
+const {
+	isCSSRequest,
+	preprocessCSS,
+	resolveConfig,
+	transformWithEsbuild,
+	//@ts-expect-error rolldown types don't exist
+	rolldownVersion,
+	//@ts-expect-error rolldown types don't exist
+	transformWithOxc
+} = vite;
 /**
  * @typedef {(code: string, filename: string) => Promise<{ code: string; map?: any; deps?: Set<string> }>} CssTransform
  */
@@ -18,7 +27,7 @@ export function vitePreprocess(opts) {
 	/** @type {import('svelte/compiler').PreprocessorGroup} */
 	const preprocessor = { name: 'vite-preprocess' };
 	if (opts?.script === true) {
-		preprocessor.script = viteScript().script;
+		preprocessor.script = rolldownVersion ? viteScriptOxc().script : viteScript().script;
 	}
 	if (opts?.style !== false) {
 		const styleOpts = typeof opts?.style == 'object' ? opts?.style : undefined;
@@ -57,6 +66,37 @@ function viteScript() {
 	};
 }
 
+/**
+ * @returns {{ script: import('svelte/compiler').Preprocessor }}
+ */
+function viteScriptOxc() {
+	return {
+		async script({ attributes, content, filename = '' }) {
+			const lang = /** @type {string} */ (attributes.lang);
+			if (!supportedScriptLangs.includes(lang)) return;
+			const { code, map } = await transformWithOxc(content, filename, {
+				lang,
+				target: 'esnext'
+				// TODO, how to pass tsconfig compilerOptions (or not needed as config is loaded for file
+				/*tsconfigRaw: {
+					compilerOptions: {
+						// svelte typescript needs this flag to work with type imports
+						importsNotUsedAsValues: 'preserve',
+						preserveValueImports: true
+					}
+				}*/
+			});
+
+			mapToRelative(map, filename);
+
+			return {
+				code,
+				map
+			};
+		}
+	};
+}
+
 /**
  * @param {import('vite').ResolvedConfig | import('vite').InlineConfig} config
  * @returns {{ style: import('svelte/compiler').Preprocessor }}

package/src/public.d.ts

@@ -22,14 +22,14 @@ export interface PluginOptions {
 	 *
 	 * @see https://github.com/micromatch/picomatch
 	 */
-	include?: Arrayable<string>;
+	include?: Arrayable<string | RegExp>;
 	/**
 	 * A `picomatch` pattern, or array of patterns, which specifies the files to be ignored by the
 	 * plugin. By default, no files are ignored.
 	 *
 	 * @see https://github.com/micromatch/picomatch
 	 */
-	exclude?: Arrayable<string>;
+	exclude?: Arrayable<string | RegExp>;
 	/**
 	 * Emit Svelte styles as virtual CSS files for Vite and other plugins to process
 	 *
@@ -187,8 +187,8 @@ interface CompileModuleOptions {
 	 * @default ['.ts','.js']
 	 */
 	extensions?: string[];
-	include?: Arrayable<string>;
-	exclude?: Arrayable<string>;
+	include?: Arrayable<string | RegExp>;
+	exclude?: Arrayable<string | RegExp>;
 }
 
 type Arrayable<T> = T | T[];

package/src/types/compile.d.ts

@@ -14,6 +14,7 @@ export interface Code {
 	map?: any;
 	dependencies?: any[];
 	hasGlobal?: boolean;
+	moduleType?: string; //rolldown-vite
 	meta?: {
 		vite?: CustomPluginOptionsVite;
 	};

package/src/types/id.d.ts

@@ -39,6 +39,13 @@ export interface SvelteModuleRequest {
 }
 
 export type IdParser = (id: string, ssr: boolean, timestamp?: number) => SvelteRequest | undefined;
+
+export type IdFilter = {
+	id: {
+		include: Array<string | RegExp>;
+		exclude: Array<string | RegExp>;
+	};
+};
 export type ModuleIdParser = (
 	id: string,
 	ssr: boolean,

package/src/utils/constants.js

@@ -29,3 +29,8 @@ export const FAQ_LINK_MISSING_EXPORTS_CONDITION =
 export const DEFAULT_SVELTE_EXT = ['.svelte'];
 export const DEFAULT_SVELTE_MODULE_INFIX = ['.svelte.'];
 export const DEFAULT_SVELTE_MODULE_EXT = ['.js', '.ts'];
+
+export const SVELTE_VIRTUAL_STYLE_SUFFIX = '?svelte&type=style&lang.css';
+export const SVELTE_VIRTUAL_STYLE_ID_REGEX = new RegExp(
+	`${SVELTE_VIRTUAL_STYLE_SUFFIX.replace(/[?.]/g, '\\$&')}$`
+);

package/src/utils/id.js

@@ -1,9 +1,13 @@
-import { createFilter, normalizePath } from 'vite';
+import { normalizePath } from 'vite';
 import fs from 'node:fs';
-import path from 'node:path';
 import process from 'node:process';
 import { log } from './log.js';
-import { DEFAULT_SVELTE_MODULE_EXT, DEFAULT_SVELTE_MODULE_INFIX } from './constants.js';
+import {
+	DEFAULT_SVELTE_EXT,
+	DEFAULT_SVELTE_MODULE_EXT,
+	DEFAULT_SVELTE_MODULE_INFIX
+} from './constants.js';
+import { arraify } from './options.js';
 
 const VITE_FS_PREFIX = '/@fs/';
 const IS_WINDOWS = process.platform === 'win32';
@@ -154,34 +158,34 @@ function stripRoot(normalizedFilename, normalizedRoot) {
 }
 
 /**
- * @param {import('../public.d.ts').Options['include'] | undefined} include
- * @param {import('../public.d.ts').Options['exclude'] | undefined} exclude
- * @param {string[]} extensions
- * @returns {(filename: string) => boolean}
+ *
+ * @param {string} s
+ * @returns {string}
  */
-function buildFilter(include, exclude, extensions) {
-	const rollupFilter = createFilter(include, exclude);
-	return (filename) => rollupFilter(filename) && extensions.some((ext) => filename.endsWith(ext));
+function escapeRE(s) {
+	return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 /**
- * @param {import('../public.d.ts').Options['include'] | undefined} include
- * @param {import('../public.d.ts').Options['exclude'] | undefined} exclude
- * @param {string[]} infixes
- * @param {string[]} extensions
- * @returns {(filename: string) => boolean}
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @returns {import('../types/id.d.ts').IdFilter}
  */
-function buildModuleFilter(include, exclude, infixes, extensions) {
-	const rollupFilter = createFilter(include, exclude);
-	return (filename) => {
-		const basename = path.basename(filename);
-
-		return (
-			rollupFilter(filename) &&
-			infixes.some((infix) => basename.includes(infix)) &&
-			extensions.some((ext) => basename.endsWith(ext))
-		);
+export function buildIdFilter(options) {
+	const { include = [], exclude = [], extensions = DEFAULT_SVELTE_EXT } = options;
+	// this regex combines configured extensions and looks for them at the end of the string or directly before first ? or #
+	const extensionsRE = new RegExp(
+		`^[^?#]+\\.(?:${extensions
+			.map((e) => (e.startsWith('.') ? e.slice(1) : e))
+			.map(escapeRE)
+			.join('|')})(?:[?#]|$)`
+	);
+	const filter = {
+		id: {
+			include: [extensionsRE, .../**@type {Array<string|RegExp>}*/ arraify(include)],
+			exclude: /**@type {Array<string|RegExp>}*/ arraify(exclude)
+		}
 	};
+	return filter;
 }
 
 /**
@@ -189,36 +193,50 @@ function buildModuleFilter(include, exclude, infixes, extensions) {
  * @returns {import('../types/id.d.ts').IdParser}
  */
 export function buildIdParser(options) {
-	const { include, exclude, extensions, root } = options;
-	const normalizedRoot = normalizePath(root);
-	const filter = buildFilter(include, exclude, extensions ?? []);
+	const normalizedRoot = normalizePath(options.root);
 	return (id, ssr, timestamp = Date.now()) => {
 		const { filename, rawQuery } = splitId(id);
-		if (filter(filename)) {
-			return parseToSvelteRequest(id, filename, rawQuery, normalizedRoot, timestamp, ssr);
-		}
+		return parseToSvelteRequest(id, filename, rawQuery, normalizedRoot, timestamp, ssr);
 	};
 }
 
 /**
  * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {import('../types/id.d.ts').ModuleIdParser}
+ * @returns {import('../types/id.d.ts').IdFilter}
  */
-export function buildModuleIdParser(options) {
+export function buildModuleIdFilter(options) {
 	const {
-		include,
-		exclude,
 		infixes = DEFAULT_SVELTE_MODULE_INFIX,
+		include = [],
+		exclude = [],
 		extensions = DEFAULT_SVELTE_MODULE_EXT
-	} = options?.experimental?.compileModule ?? {};
+	} = options.experimental?.compileModule ?? {};
+	// this regex combines configured infixes and extensions
+	// and looks for them at the end of the string or directly before first ? or #
+	const infixWithExtRE = new RegExp(
+		`^[^?#]+(?:${infixes.map(escapeRE).join('|')})(?:[^.\\\\/]+\\.)*(?:${extensions
+			.map((e) => (e.startsWith('.') ? e.slice(1) : e))
+			.map(escapeRE)
+			.join('|')})(?:[?#]|$)`
+	);
+	return {
+		id: {
+			include: [infixWithExtRE, .../**@type {Array<string|RegExp>}*/ arraify(include)],
+			exclude: /**@type {Array<string|RegExp>}*/ arraify(exclude)
+		}
+	};
+}
+
+/**
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ * @returns {import('../types/id.d.ts').ModuleIdParser}
+ */
+export function buildModuleIdParser(options) {
 	const root = options.root;
 	const normalizedRoot = normalizePath(root);
-	const filter = buildModuleFilter(include, exclude, infixes, extensions);
 	return (id, ssr, timestamp = Date.now()) => {
 		const { filename, rawQuery } = splitId(id);
-		if (filter(filename)) {
-			return parseToSvelteModuleRequest(id, filename, rawQuery, normalizedRoot, timestamp, ssr);
-		}
+		return parseToSvelteModuleRequest(id, filename, rawQuery, normalizedRoot, timestamp, ssr);
 	};
 }
 

package/src/utils/load-svelte-config.js

@@ -1,21 +1,12 @@
-import { createRequire } from 'node:module';
 import path from 'node:path';
 import process from 'node:process';
 import fs from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { log } from './log.js';
 
-// used to require cjs config in esm.
-// NOTE dynamic import() cjs technically works, but timestamp query cache bust
-// have no effect, likely because it has another internal cache?
-/** @type {NodeRequire}*/
-let esmRequire;
-
-export const knownSvelteConfigNames = [
-	'svelte.config.js',
-	'svelte.config.cjs',
-	'svelte.config.mjs'
-];
+export const knownSvelteConfigNames = ['js', 'ts', 'mjs', 'mts'].map(
+	(ext) => `svelte.config.${ext}`
+);
 
 /**
  * @param {string} filePath
@@ -36,56 +27,23 @@ export async function loadSvelteConfig(viteConfig, inlineOptions) {
 	}
 	const configFile = findConfigToLoad(viteConfig, inlineOptions);
 	if (configFile) {
-		let err;
-		// try to use dynamic import for svelte.config.js first
-		if (configFile.endsWith('.js') || configFile.endsWith('.mjs')) {
-			try {
-				const result = await dynamicImportDefault(
-					pathToFileURL(configFile).href,
-					fs.statSync(configFile).mtimeMs
-				);
-				if (result != null) {
-					return {
-						...result,
-						configFile
-					};
-				} else {
-					throw new Error(`invalid export in ${configFile}`);
-				}
-			} catch (e) {
-				log.error(`failed to import config ${configFile}`, e);
-				err = e;
-			}
-		}
-		// cjs or error with dynamic import
-		if (!configFile.endsWith('.mjs')) {
-			try {
-				// identify which require function to use (esm and cjs mode)
-				const _require = import.meta.url
-					? (esmRequire ?? (esmRequire = createRequire(import.meta.url)))
-					: // eslint-disable-next-line no-undef
-						require;
-
-				// avoid loading cached version on reload
-				delete _require.cache[_require.resolve(configFile)];
-				const result = _require(configFile);
-				if (result != null) {
-					return {
-						...result,
-						configFile
-					};
-				} else {
-					throw new Error(`invalid export in ${configFile}`);
-				}
-			} catch (e) {
-				log.error(`failed to require config ${configFile}`, e);
-				if (!err) {
-					err = e;
-				}
+		try {
+			const result = await dynamicImportDefault(
+				pathToFileURL(configFile).href,
+				fs.statSync(configFile).mtimeMs
+			);
+			if (result != null) {
+				return {
+					...result,
+					configFile
+				};
+			} else {
+				throw new Error(`invalid export in ${configFile}`);
 			}
+		} catch (e) {
+			log.error(`failed to import config ${configFile}`, e);
+			throw e;
 		}
-		// failed to load existing config file
-		throw err;
 	}
 }
 

package/src/utils/{esbuild.js → optimizer-plugins.js}

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import * as svelte from 'svelte/compiler';
 import { log } from './log.js';
-import { toESBuildError } from './error.js';
+import { toESBuildError, toRollupError } from './error.js';
 import { safeBase64Hash } from './hash.js';
 import { normalize } from './id.js';
 
@@ -9,42 +9,94 @@ import { normalize } from './id.js';
  * @typedef {NonNullable<import('vite').DepOptimizationOptions['esbuildOptions']>} EsbuildOptions
  * @typedef {NonNullable<EsbuildOptions['plugins']>[number]} EsbuildPlugin
  */
+/**
+ * @typedef {NonNullable<import('vite').Rollup.Plugin>} RollupPlugin
+ */
 
-export const facadeEsbuildSveltePluginName = 'vite-plugin-svelte:facade';
-export const facadeEsbuildSvelteModulePluginName = 'vite-plugin-svelte-module:facade';
+export const optimizeSveltePluginName = 'vite-plugin-svelte:optimize';
+export const optimizeSvelteModulePluginName = 'vite-plugin-svelte-module:optimize';
 
 /**
+ * @param {EsbuildPlugin} plugin
  * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {EsbuildPlugin}
  */
-export function esbuildSveltePlugin(options) {
-	return {
-		name: 'vite-plugin-svelte:optimize-svelte',
-		setup(build) {
-			// Skip in scanning phase as Vite already handles scanning Svelte files.
-			// Otherwise this would heavily slow down the scanning phase.
-			if (build.initialOptions.plugins?.some((v) => v.name === 'vite:dep-scan')) return;
+export function patchESBuildOptimizerPlugin(plugin, options) {
+	const components = plugin.name === optimizeSveltePluginName;
+	const compileFn = components ? compileSvelte : compileSvelteModule;
+	const statsName = components ? 'prebundle library components' : 'prebundle library modules';
+	const filter = components ? /\.svelte(?:\?.*)?$/ : /\.svelte\.[jt]s(?:\?.*)?$/;
+	plugin.setup = (build) => {
+		if (build.initialOptions.plugins?.some((v) => v.name === 'vite:dep-scan')) return;
 
-			const filter = /\.svelte(?:\?.*)?$/;
-			/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
-			let statsCollection;
-			build.onStart(() => {
-				statsCollection = options.stats?.startCollection('prebundle library components', {
-					logResult: (c) => c.stats.length > 1
-				});
+		/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
+		let statsCollection;
+		build.onStart(() => {
+			statsCollection = options.stats?.startCollection(statsName, {
+				logResult: (c) => c.stats.length > 1
 			});
-			build.onLoad({ filter }, async ({ path: filename }) => {
-				const code = readFileSync(filename, 'utf8');
-				try {
-					const contents = await compileSvelte(options, { filename, code }, statsCollection);
-					return { contents };
-				} catch (e) {
-					return { errors: [toESBuildError(e, options)] };
+		});
+		build.onLoad({ filter }, async ({ path: filename }) => {
+			const code = readFileSync(filename, 'utf8');
+			try {
+				const result = await compileFn(options, { filename, code }, statsCollection);
+				const contents = result.map
+					? result.code + '//# sourceMappingURL=' + result.map.toUrl()
+					: result.code;
+				return { contents };
+			} catch (e) {
+				return { errors: [toESBuildError(e, options)] };
+			}
+		});
+		build.onEnd(() => {
+			statsCollection?.finish();
+		});
+	};
+}
+
+/**
+ * @param {RollupPlugin} plugin
+ * @param {import('../types/options.d.ts').ResolvedOptions} options
+ */
+export function patchRolldownOptimizerPlugin(plugin, options) {
+	const components = plugin.name === optimizeSveltePluginName;
+	const compileFn = components ? compileSvelte : compileSvelteModule;
+	const statsName = components ? 'prebundle library components' : 'prebundle library modules';
+	const includeRe = components ? /^[^?#]+\.svelte(?:[?#]|$)/ : /^[^?#]+\.svelte\.[jt]s(?:[?#]|$)/;
+	/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
+	let statsCollection;
+
+	plugin.options = (opts) => {
+		// @ts-expect-error plugins is an array here
+		const isScanner = opts.plugins.some(
+			(/** @type {{ name: string; }} */ p) => p.name === 'vite:dep-scan:resolve'
+		);
+		if (isScanner) {
+			delete plugin.buildStart;
+			delete plugin.transform;
+			delete plugin.buildEnd;
+		} else {
+			plugin.transform = {
+				filter: { id: includeRe },
+				/**
+				 * @param {string} code
+				 * @param {string} filename
+				 */
+				async handler(code, filename) {
+					try {
+						return await compileFn(options, { filename, code }, statsCollection);
+					} catch (e) {
+						throw toRollupError(e, options);
+					}
 				}
-			});
-			build.onEnd(() => {
+			};
+			plugin.buildStart = () => {
+				statsCollection = options.stats?.startCollection(statsName, {
+					logResult: (c) => c.stats.length > 1
+				});
+			};
+			plugin.buildEnd = () => {
 				statsCollection?.finish();
-			});
+			};
 		}
 	};
 }
@@ -53,7 +105,7 @@ export function esbuildSveltePlugin(options) {
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  * @param {{ filename: string, code: string }} input
  * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} [statsCollection]
- * @returns {Promise<string>}
+ * @returns {Promise<import('../types/compile.d.ts').Code>}
  */
 async function compileSvelte(options, { filename, code }, statsCollection) {
 	let css = options.compilerOptions.css;
@@ -114,44 +166,9 @@ async function compileSvelte(options, { filename, code }, statsCollection) {
 	if (endStat) {
 		endStat();
 	}
-	return compiled.js.map
-		? compiled.js.code + '//# sourceMappingURL=' + compiled.js.map.toUrl()
-		: compiled.js.code;
-}
-
-/**
- * @param {import('../types/options.d.ts').ResolvedOptions} options
- * @returns {EsbuildPlugin}
- */
-export function esbuildSvelteModulePlugin(options) {
 	return {
-		name: 'vite-plugin-svelte-module:optimize-svelte',
-		setup(build) {
-			// Skip in scanning phase as Vite already handles scanning Svelte files.
-			// Otherwise this would heavily slow down the scanning phase.
-			if (build.initialOptions.plugins?.some((v) => v.name === 'vite:dep-scan')) return;
-
-			const filter = /\.svelte\.[jt]s(?:\?.*)?$/;
-			/** @type {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection | undefined} */
-			let statsCollection;
-			build.onStart(() => {
-				statsCollection = options.stats?.startCollection('prebundle library modules', {
-					logResult: (c) => c.stats.length > 1
-				});
-			});
-			build.onLoad({ filter }, async ({ path: filename }) => {
-				const code = readFileSync(filename, 'utf8');
-				try {
-					const contents = await compileSvelteModule(options, { filename, code }, statsCollection);
-					return { contents };
-				} catch (e) {
-					return { errors: [toESBuildError(e, options)] };
-				}
-			});
-			build.onEnd(() => {
-				statsCollection?.finish();
-			});
-		}
+		...compiled.js,
+		moduleType: 'js'
 	};
 }
 
@@ -159,7 +176,7 @@ export function esbuildSvelteModulePlugin(options) {
  * @param {import('../types/options.d.ts').ResolvedOptions} options
  * @param {{ filename: string; code: string }} input
  * @param {import('../types/vite-plugin-svelte-stats.d.ts').StatCollection} [statsCollection]
- * @returns {Promise<string>}
+ * @returns {Promise<import('../types/compile.d.ts').Code>}
  */
 async function compileSvelteModule(options, { filename, code }, statsCollection) {
 	const endStat = statsCollection?.start(filename);
@@ -171,7 +188,8 @@ async function compileSvelteModule(options, { filename, code }, statsCollection)
 	if (endStat) {
 		endStat();
 	}
-	return compiled.js.map
-		? compiled.js.code + '//# sourceMappingURL=' + compiled.js.map.toUrl()
-		: compiled.js.code;
+	return {
+		...compiled.js,
+		moduleType: 'js'
+	};
 }

package/src/utils/options.js

@@ -1,11 +1,14 @@
 import process from 'node:process';
-import {
+import * as vite from 'vite';
+const {
 	defaultClientMainFields,
 	defaultServerMainFields,
 	defaultClientConditions,
 	defaultServerConditions,
-	normalizePath
-} from 'vite';
+	normalizePath,
+	//@ts-expect-error rolldownVersion not in type
+	rolldownVersion
+} = vite;
 import { isDebugNamespaceEnabled, log } from './log.js';
 import { loadSvelteConfig } from './load-svelte-config.js';
 import {
@@ -18,11 +21,11 @@ import {
 
 import path from 'node:path';
 import {
-	esbuildSvelteModulePlugin,
-	esbuildSveltePlugin,
-	facadeEsbuildSvelteModulePluginName,
-	facadeEsbuildSveltePluginName
-} from './esbuild.js';
+	optimizeSvelteModulePluginName,
+	optimizeSveltePluginName,
+	patchESBuildOptimizerPlugin,
+	patchRolldownOptimizerPlugin
+} from './optimizer-plugins.js';
 import { addExtraPreprocessors } from './preprocess.js';
 import deepmerge from 'deepmerge';
 import {
@@ -386,17 +389,39 @@ export async function buildExtraViteConfig(options, config) {
 		extraViteConfig.optimizeDeps = {
 			...extraViteConfig.optimizeDeps,
 			// Experimental Vite API to allow these extensions to be scanned and prebundled
-			extensions: options.extensions ?? ['.svelte'],
-			// Add esbuild plugin to prebundle Svelte files.
-			// Currently a placeholder as more information is needed after Vite config is resolved,
-			// the real Svelte plugin is added in `patchResolvedViteConfig()`
-			esbuildOptions: {
+			extensions: options.extensions ?? ['.svelte']
+		};
+		// Add optimizer plugins to prebundle Svelte files.
+		// Currently a placeholder as more information is needed after Vite config is resolved,
+		// the added plugins are patched in `patchResolvedViteConfig()`
+		if (rolldownVersion) {
+			/**
+			 *
+			 * @param {string} name
+			 * @returns {import('vite').Rollup.Plugin}
+			 */
+			const placeholderRolldownOptimizerPlugin = (name) => ({
+				name,
+				options() {},
+				buildStart() {},
+				buildEnd() {},
+				transform: { filter: { id: /^$/ }, handler() {} }
+			});
+			//@ts-expect-error rolldown types not finished
+			extraViteConfig.optimizeDeps.rollupOptions = {
 				plugins: [
-					{ name: facadeEsbuildSveltePluginName, setup: () => {} },
-					{ name: facadeEsbuildSvelteModulePluginName, setup: () => {} }
+					placeholderRolldownOptimizerPlugin(optimizeSveltePluginName),
+					placeholderRolldownOptimizerPlugin(optimizeSvelteModulePluginName)
 				]
-			}
-		};
+			};
+		} else {
+			extraViteConfig.optimizeDeps.esbuildOptions = {
+				plugins: [
+					{ name: optimizeSveltePluginName, setup: () => {} },
+					{ name: optimizeSvelteModulePluginName, setup: () => {} }
+				]
+			};
+		}
 	}
 
 	// enable hmrPartialAccept if not explicitly disabled
@@ -594,19 +619,23 @@ export function patchResolvedViteConfig(viteConfig, options) {
 			}
 		}
 	}
-
-	// replace facade esbuild plugin with a real one
-	const facadeEsbuildSveltePlugin = viteConfig.optimizeDeps.esbuildOptions?.plugins?.find(
-		(plugin) => plugin.name === facadeEsbuildSveltePluginName
-	);
-	if (facadeEsbuildSveltePlugin) {
-		Object.assign(facadeEsbuildSveltePlugin, esbuildSveltePlugin(options));
-	}
-	const facadeEsbuildSvelteModulePlugin = viteConfig.optimizeDeps.esbuildOptions?.plugins?.find(
-		(plugin) => plugin.name === facadeEsbuildSvelteModulePluginName
-	);
-	if (facadeEsbuildSvelteModulePlugin) {
-		Object.assign(facadeEsbuildSvelteModulePlugin, esbuildSvelteModulePlugin(options));
+	if (rolldownVersion) {
+		const plugins =
+			// @ts-expect-error not typed
+			viteConfig.optimizeDeps.rollupOptions?.plugins?.filter((p) =>
+				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
+			) ?? [];
+		for (const plugin of plugins) {
+			patchRolldownOptimizerPlugin(plugin, options);
+		}
+	} else {
+		const plugins =
+			viteConfig.optimizeDeps.esbuildOptions?.plugins?.filter((p) =>
+				[optimizeSveltePluginName, optimizeSvelteModulePluginName].includes(p.name)
+			) ?? [];
+		for (const plugin of plugins) {
+			patchESBuildOptimizerPlugin(plugin, options);
+		}
 	}
 }
 
@@ -647,9 +676,9 @@ export function ensureConfigEnvironmentConditions(name, config, opts) {
 
 /**
  * @template T
- * @param {T | T[]} value
+ * @param {T | T[] | null | undefined } value
  * @returns {T[]}
  */
-function arraify(value) {
-	return Array.isArray(value) ? value : [value];
+export function arraify(value) {
+	return value == null ? [] : Array.isArray(value) ? value : [value];
 }

package/types/index.d.ts

@@ -22,14 +22,14 @@ declare module '@sveltejs/vite-plugin-svelte' {
 		 *
 		 * @see https://github.com/micromatch/picomatch
 		 */
-		include?: Arrayable<string>;
+		include?: Arrayable<string | RegExp>;
 		/**
 		 * A `picomatch` pattern, or array of patterns, which specifies the files to be ignored by the
 		 * plugin. By default, no files are ignored.
 		 *
 		 * @see https://github.com/micromatch/picomatch
 		 */
-		exclude?: Arrayable<string>;
+		exclude?: Arrayable<string | RegExp>;
 		/**
 		 * Emit Svelte styles as virtual CSS files for Vite and other plugins to process
 		 *
@@ -187,8 +187,8 @@ declare module '@sveltejs/vite-plugin-svelte' {
 		 * @default ['.ts','.js']
 		 */
 		extensions?: string[];
-		include?: Arrayable<string>;
-		exclude?: Arrayable<string>;
+		include?: Arrayable<string | RegExp>;
+		exclude?: Arrayable<string | RegExp>;
 	}
 
 	type Arrayable<T> = T | T[];

package/types/index.d.ts.map

@@ -26,6 +26,6 @@
 		null,
 		null
 	],
-	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;iBCxKtBC,MAAMA;iBCXNC,cAAcA;iBCgBRC,gBAAgBA",
+	"mappings": ";;;;aAIYA,OAAOA;;WAETC,mBAAmBA;;;;;;;;;;;kBAWZC,aAAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgGbC,YAAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAiDnBC,mBAAmBA;;;;;;;;;;;;;;;;WAgBnBC,oBAAoBA;;;;;;;;;;;;;;;MAezBC,SAASA;;kBAEGC,qBAAqBA;;;;;;;;;;;;;iBC/JtBC,MAAMA;iBCXNC,cAAcA;iBCFRC,gBAAgBA",
 	"ignoreList": []
 }