@voidzero-dev/vite-plus-core 0.2.4 → 0.2.6

package/dist/tsdown/{tsc-CdZE7QwS.js → tsc-zcbB6ZVY.js}

@@ -1,45 +1,45 @@
-import { r as createDebug } from "./main-BlTcyuFi.js";
-import { l as RE_DTS, u as RE_DTS_MAP } from "./build-B_nvJe4A-CvbtVBxy.js";
-import { n as globalContext } from "./tsc-context-CX_GXdyS.js";
-import { createRequire } from "node:module";
+import { r as createDebug } from "./main-BdzlWPt6.js";
+import { h as RE_DTS_MAP, m as RE_DTS } from "./target-CNxIDvSz-eoHNdJNs.js";
+import { n as globalContext } from "./tsc-context-CA76SkkZ.js";
+import { t as requireTS } from "./load-tsc-BKULZsrs-BFmeD6Bu.js";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-const ts = createRequire(import.meta.url)("typescript");
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-const debug$4 = createDebug("rolldown-plugin-dts:tsc-system");
+//#region ../../node_modules/.pnpm/rolldown-plugin-dts@0.27.12_@typescript+native-preview@7.0.0-dev.20260605.1_oxc-resolve_d94a4da753642eee691447f5bf042e95/node_modules/rolldown-plugin-dts/dist/tsc-KtFHcISk.mjs
+const debug$3 = createDebug("rolldown-plugin-dts:tsc-system");
+const ts$3 = requireTS();
 /**
 * A system that writes files to both memory and disk. It will try read files
 * from memory firstly and fallback to disk if not found.
 */
 function createFsSystem(files) {
 	return {
-		...ts.sys,
+		...ts$3.sys,
 		write(message) {
-			debug$4(message);
+			debug$3(message);
 		},
 		resolvePath(path) {
 			if (files.has(path)) return path;
-			return ts.sys.resolvePath(path);
+			return ts$3.sys.resolvePath(path);
 		},
 		directoryExists(directory) {
 			if (Array.from(files.keys()).some((path) => path.startsWith(directory))) return true;
-			return ts.sys.directoryExists(directory);
+			return ts$3.sys.directoryExists(directory);
 		},
 		fileExists(fileName) {
 			if (files.has(fileName)) return true;
-			return ts.sys.fileExists(fileName);
+			return ts$3.sys.fileExists(fileName);
 		},
 		readFile(fileName, ...args) {
 			if (files.has(fileName)) return files.get(fileName);
-			return ts.sys.readFile(fileName, ...args);
+			return ts$3.sys.readFile(fileName, ...args);
 		},
 		writeFile(path, data, ...args) {
 			files.set(path, data);
-			ts.sys.writeFile(path, data, ...args);
+			ts$3.sys.writeFile(path, data, ...args);
 		},
 		deleteFile(fileName, ...args) {
 			files.delete(fileName);
-			ts.sys.deleteFile?.(fileName, ...args);
+			ts$3.sys.deleteFile?.(fileName, ...args);
 		}
 	};
 }
@@ -54,17 +54,25 @@ function createMemorySystem(files) {
 		}
 	};
 }
+const ts$2 = requireTS();
 const formatHost = {
-	getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
-	getNewLine: () => ts.sys.newLine,
-	getCanonicalFileName: ts.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
+	getCurrentDirectory: () => ts$2.sys.getCurrentDirectory(),
+	getNewLine: () => ts$2.sys.newLine,
+	getCanonicalFileName: ts$2.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
 };
 const stripPrivateFields = (ctx) => {
+	const recurseCtx = {
+		...ctx,
+		startLexicalEnvironment: () => {},
+		suspendLexicalEnvironment: () => {},
+		resumeLexicalEnvironment: () => {},
+		endLexicalEnvironment: () => void 0
+	};
 	const visitor = (node) => {
-		if (ts.isPropertySignature(node) && ts.isPrivateIdentifier(node.name)) return ctx.factory.updatePropertySignature(node, node.modifiers, ctx.factory.createStringLiteral(node.name.text), node.questionToken, node.type);
-		return ts.visitEachChild(node, visitor, ctx);
+		if (ts$2.isPropertySignature(node) && ts$2.isPrivateIdentifier(node.name)) return ctx.factory.updatePropertySignature(node, node.modifiers, ctx.factory.createStringLiteral(node.name.text), node.questionToken, node.type);
+		return ts$2.visitEachChild(node, visitor, recurseCtx);
 	};
-	return (sourceFile) => ts.visitNode(sourceFile, visitor, ts.isSourceFile) ?? sourceFile;
+	return (sourceFile) => ts$2.visitNode(sourceFile, visitor, ts$2.isSourceFile) ?? sourceFile;
 };
 const customTransformers = { afterDeclarations: [stripPrivateFields] };
 function setSourceMapRoot(map, originalFilePath, finalFilePath) {
@@ -74,22 +82,23 @@ function setSourceMapRoot(map, originalFilePath, finalFilePath) {
 	const finalDir = path.posix.dirname(pathToFileURL(finalFilePath).pathname);
 	if (originalDir !== finalDir) map.sourceRoot = path.posix.relative(finalDir, originalDir);
 }
-const debug$3 = createDebug("rolldown-plugin-dts:tsc-build");
+const ts$1 = requireTS();
+const debug$2 = createDebug("rolldown-plugin-dts:tsc-build");
 function tscEmitBuild(tscOptions) {
 	const { id, tsconfig, incremental, context = globalContext, sourcemap } = tscOptions;
-	debug$3(`running tscEmitBuild id: ${id}, tsconfig: ${tsconfig}, incremental: ${incremental}`);
+	debug$2(`running tscEmitBuild id: ${id}, tsconfig: ${tsconfig}, incremental: ${incremental}`);
 	if (!tsconfig) return { error: "[rolldown-plugin-dts] build mode requires a tsconfig path" };
 	const fsSystem = (incremental ? createFsSystem : createMemorySystem)(context.files);
 	const resolvedId = fsSystem.resolvePath(id);
-	if (resolvedId !== id) debug$3(`resolved id from ${id} to ${resolvedId}`);
+	if (resolvedId !== id) debug$2(`resolved id from ${id} to ${resolvedId}`);
 	const project = getOrBuildProjects(context, fsSystem, tsconfig, !incremental, sourcemap).get(resolvedId);
 	if (!project) {
-		debug$3(`unable to locate a project containing ${resolvedId}`);
+		debug$2(`unable to locate a project containing ${resolvedId}`);
 		return { error: `Unable to locate ${id} from the given tsconfig file ${tsconfig}` };
 	}
-	debug$3(`loaded project ${project.tsconfigPath} for ${id}`);
+	debug$2(`loaded project ${project.tsconfigPath} for ${id}`);
 	const ignoreCase = !fsSystem.useCaseSensitiveFileNames;
-	const outputFiles = ts.getOutputFileNames(project.parsedConfig, resolvedId, ignoreCase);
+	const outputFiles = ts$1.getOutputFileNames(project.parsedConfig, resolvedId, ignoreCase);
 	let code;
 	let map;
 	for (const outputFile of outputFiles) {
@@ -117,20 +126,20 @@ function tscEmitBuild(tscOptions) {
 		map
 	};
 	if (incremental) {
-		debug$3(`incremental build failed`);
+		debug$2(`incremental build failed`);
 		return tscEmitBuild({
 			...tscOptions,
 			incremental: false
 		});
 	}
-	debug$3(`unable to build .d.ts file for ${id}`);
+	debug$2(`unable to build .d.ts file for ${id}`);
 	if (project.parsedConfig.options.declaration !== true) return { error: `Unable to build .d.ts file for ${id}; Make sure the "declaration" option is set to true in ${project.tsconfigPath}` };
 	return { error: `Unable to build .d.ts file for ${id}; This seems like a bug of rolldown-plugin-dts. Please report this issue to https://github.com/sxzz/rolldown-plugin-dts/issues` };
 }
 function getOrBuildProjects(context, fsSystem, tsconfig, force, sourcemap) {
 	let projectMap = context.projects.get(tsconfig);
 	if (projectMap) {
-		debug$3(`skip building projects for ${tsconfig}`);
+		debug$2(`skip building projects for ${tsconfig}`);
 		return projectMap;
 	}
 	projectMap = buildProjects(fsSystem, tsconfig, force, sourcemap);
@@ -141,17 +150,18 @@ function getOrBuildProjects(context, fsSystem, tsconfig, force, sourcemap) {
 * Use TypeScript compiler to build all projects referenced
 */
 function buildProjects(fsSystem, tsconfig, force, sourcemap) {
-	debug$3(`start building projects for ${tsconfig}`);
+	debug$2(`start building projects for ${tsconfig}`);
 	const projects = collectProjectGraph(tsconfig, fsSystem, force, sourcemap);
-	debug$3("collected %d projects: %j", projects.length, projects.map((project) => project.tsconfigPath));
-	const host = ts.createSolutionBuilderHost(fsSystem, createProgramWithPatchedCompilerOptions);
-	debug$3(`built solution for ${tsconfig} with exit status ${ts.createSolutionBuilder(host, [tsconfig], {
+	debug$2("collected %d projects: %j", projects.length, projects.map((project) => project.tsconfigPath));
+	const host = ts$1.createSolutionBuilderHost(fsSystem, createProgramWithPatchedCompilerOptions);
+	const exitStatus = ts$1.createSolutionBuilder(host, [tsconfig], {
 		force,
 		verbose: true
 	}).build(void 0, void 0, void 0, (project) => {
-		debug$3(`transforming project ${project}`);
+		debug$2(`transforming project ${project}`);
 		return customTransformers;
-	})}`);
+	});
+	debug$2(`built solution for ${tsconfig} with exit status ${exitStatus}`);
 	const sourceFileToProjectMap = /* @__PURE__ */ new Map();
 	for (const project of projects) for (const fileName of project.parsedConfig.fileNames) sourceFileToProjectMap.set(fsSystem.resolvePath(fileName), project);
 	return sourceFileToProjectMap;
@@ -179,19 +189,19 @@ function collectProjectGraph(rootTsconfigPath, fsSystem, force, sourcemap) {
 			tsconfigPath,
 			parsedConfig
 		});
-		for (const ref of parsedConfig.projectReferences ?? []) stack.push(ts.resolveProjectReferencePath(ref));
+		for (const ref of parsedConfig.projectReferences ?? []) stack.push(ts$1.resolveProjectReferencePath(ref));
 	}
 	return projects;
 }
 function parseTsconfig(tsconfigPath, fsSystem) {
 	const diagnostics = [];
-	const parsedConfig = ts.getParsedCommandLineOfConfigFile(tsconfigPath, void 0, {
+	const parsedConfig = ts$1.getParsedCommandLineOfConfigFile(tsconfigPath, void 0, {
 		...fsSystem,
 		onUnRecoverableConfigFileDiagnostic: (diagnostic) => {
 			diagnostics.push(diagnostic);
 		}
 	});
-	if (diagnostics.length) throw new Error(`[rolldown-plugin-dts] Unable to read ${tsconfigPath}: ${ts.formatDiagnostics(diagnostics, formatHost)}`);
+	if (diagnostics.length) throw new Error(`[rolldown-plugin-dts] Unable to read ${tsconfigPath}: ${ts$1.formatDiagnostics(diagnostics, formatHost)}`);
 	return parsedConfig;
 }
 function patchCompilerOptions(options, extraOptions) {
@@ -223,71 +233,10 @@ function patchCompilerOptions(options, extraOptions) {
 	return options;
 }
 const createProgramWithPatchedCompilerOptions = (rootNames, options, ...args) => {
-	return ts.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, patchCompilerOptions(options ?? {}, null), ...args);
+	return ts$1.createEmitAndSemanticDiagnosticsBuilderProgram(rootNames, patchCompilerOptions(options ?? {}, null), ...args);
 };
-const debug$2 = createDebug("rolldown-plugin-dts:volar");
-function loadVueLanguageTools() {
-	debug$2("loading vue language tools");
-	try {
-		const vueTscPath = __require.resolve("vue-tsc");
-		return {
-			volarTs: __require(__require.resolve("@volar/typescript", { paths: [vueTscPath] })),
-			vue: __require(__require.resolve("@vue/language-core", { paths: [vueTscPath] }))
-		};
-	} catch (error) {
-		debug$2("vue language tools not found", error);
-		throw new Error("Failed to load vue language tools. Please manually install vue-tsc.", { cause: error });
-	}
-}
-function initVueLanguageTools() {
-	const { vue, volarTs: { proxyCreateProgram } } = loadVueLanguageTools();
-	const getLanguagePlugin = (ts, options) => {
-		const $rootDir = options.options.$rootDir;
-		const $configRaw = options.options.$configRaw;
-		const resolver = new vue.CompilerOptionsResolver(ts, ts.sys.readFile);
-		resolver.addConfig($configRaw?.vueCompilerOptions ?? {}, $rootDir);
-		const vueOptions = resolver.build();
-		return vue.createVueLanguagePlugin(ts, options.options, vueOptions, (id) => id);
-	};
-	return {
-		proxyCreateProgram,
-		getLanguagePlugin
-	};
-}
-function initTsMacro() {
-	const debug = createDebug("rolldown-plugin-dts:ts-macro");
-	debug("loading ts-macro language tools");
-	try {
-		const tsMacroPath = __require.resolve("@ts-macro/tsc");
-		const { proxyCreateProgram } = __require(__require.resolve("@volar/typescript", { paths: [tsMacroPath] }));
-		const tsMacro = __require(__require.resolve("@ts-macro/language-plugin", { paths: [tsMacroPath] }));
-		const { getOptions } = __require(__require.resolve("@ts-macro/language-plugin/options", { paths: [tsMacroPath] }));
-		const getLanguagePlugin = (ts, options) => {
-			const $rootDir = options.options.$rootDir;
-			return tsMacro.getLanguagePlugins(ts, options.options, getOptions(ts, $rootDir))[0];
-		};
-		return {
-			proxyCreateProgram,
-			getLanguagePlugin
-		};
-	} catch (error) {
-		debug("ts-macro language tools not found", error);
-		throw new Error("Failed to load ts-macro language tools. Please manually install @ts-macro/tsc.", { cause: error });
-	}
-}
-function createProgramFactory(ts, options) {
-	const vueLanguageTools = options.vue ? initVueLanguageTools() : void 0;
-	const tsMacroLanguageTools = options.tsMacro ? initTsMacro() : void 0;
-	const proxyCreateProgram = vueLanguageTools?.proxyCreateProgram || tsMacroLanguageTools?.proxyCreateProgram;
-	if (!proxyCreateProgram) return ts.createProgram;
-	return proxyCreateProgram(ts, ts.createProgram, (ts, options) => {
-		const languagePlugins = [];
-		if (vueLanguageTools) languagePlugins.push(vueLanguageTools.getLanguagePlugin(ts, options));
-		if (tsMacroLanguageTools) languagePlugins.push(tsMacroLanguageTools.getLanguagePlugin(ts, options));
-		return { languagePlugins };
-	});
-}
 const debug$1 = createDebug("rolldown-plugin-dts:tsc-compiler");
+const ts = requireTS();
 const defaultCompilerOptions = {
 	declaration: true,
 	noEmit: false,
@@ -320,14 +269,10 @@ function createOrGetTsModule(options) {
 	context.programs.push(module.program);
 	return module;
 }
-function createTsProgram({ entries, id, tsconfig, tsconfigRaw, vue, tsMacro, cwd, context = globalContext }) {
+function createTsProgram({ entries, id, tsconfig, tsconfigRaw, volarContext, cwd, context = globalContext }) {
 	const fsSystem = createFsSystem(context.files);
 	const baseDir = tsconfig ? path.dirname(tsconfig) : cwd;
-	const parsedConfig = ts.parseJsonConfigFileContent(tsconfigRaw, fsSystem, baseDir, void 0, void 0, void 0, vue ? [{
-		extension: "vue",
-		isMixedContent: true,
-		scriptKind: ts.ScriptKind.Deferred
-	}] : void 0);
+	const parsedConfig = ts.parseJsonConfigFileContent(tsconfigRaw, fsSystem, baseDir, void 0, void 0, void 0, volarContext.getExtraFileExtensions());
 	debug$1(`creating program for root project: ${baseDir}`);
 	return createTsProgramFromParsedConfig({
 		parsedConfig,
@@ -335,23 +280,20 @@ function createTsProgram({ entries, id, tsconfig, tsconfigRaw, vue, tsMacro, cwd
 		baseDir,
 		id,
 		entries,
-		vue,
-		tsMacro
+		volarContext
 	});
 }
-function createTsProgramFromParsedConfig({ parsedConfig, fsSystem, baseDir, id, entries, vue, tsMacro }) {
+function createTsProgramFromParsedConfig({ parsedConfig, fsSystem, baseDir, id, entries, volarContext }) {
 	const compilerOptions = {
 		...defaultCompilerOptions,
 		...parsedConfig.options,
 		$configRaw: parsedConfig.raw,
-		$rootDir: baseDir
+		$rootDir: baseDir,
+		...volarContext.plugins.length ? { allowNonTsExtensions: true } : void 0
 	};
 	const rootNames = [...new Set([id, ...entries || parsedConfig.fileNames].map((f) => fsSystem.resolvePath(f)))];
 	const host = ts.createCompilerHost(compilerOptions, true);
-	const program = createProgramFactory(ts, {
-		vue,
-		tsMacro
-	})({
+	const program = volarContext.getCreateProgram(ts)({
 		rootNames,
 		options: compilerOptions,
 		host,
@@ -404,7 +346,6 @@ function tscEmitCompiler(tscOptions) {
 	};
 }
 const debug = createDebug("rolldown-plugin-dts:tsc");
-debug(`loaded typescript: ${ts.version}`);
 function tscEmit(tscOptions) {
 	debug(`running tscEmit ${tscOptions.id}`);
 	if (tscOptions.build) return tscEmitBuild(tscOptions);

package/dist/tsdown/tsdown-css.js

@@ -1,12 +1,12 @@
-import { m as __toESM, n as importWithError, s as resolveComma, u as toArray } from "./general-Cp4NiJNK-CbyrS9q1.js";
-import { t as expandBaselineTarget } from "./target-CqeSqtms-FAqYuGyB.js";
-import "./internal-bfoxcI4F.js";
+import { A as __toESM, C as resolveComma, E as toArray, v as importWithError } from "./main-BdzlWPt6.js";
+import { i as expandBaselineTarget } from "./target-CNxIDvSz-eoHNdJNs.js";
+import "./internal-C7ewSPAZ.js";
 import path from "node:path";
 import { readFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { ResolverFactory } from "@voidzero-dev/vite-plus-core/rolldown/experimental";
-//#region ../../node_modules/.pnpm/@tsdown+css@0.22.3_jiti@2.7.0_postcss-import@16.1.1_postcss@8.5.16__postcss-modules@6.0_8815f8f9084693f5f3ebee14fa13c42a/node_modules/@tsdown/css/dist/index.mjs
+//#region ../../node_modules/.pnpm/@tsdown+css@0.22.13_jiti@2.7.0_postcss-import@16.1.1_postcss@8.5.20__postcss@8.5.20_sas_3e4d0025e048aeda9bd895926fc2faf1/node_modules/@tsdown/css/dist/index.mjs
 const defaultCssBundleName = "style.css";
 function resolveCssOptions(options = {}, topLevelTarget, unbundle) {
 	let cssTarget;
@@ -124,7 +124,8 @@ const PREPROCESSOR_LANGS = {
 	stylus: "stylus"
 };
 function getPreprocessorLang(filename) {
-	return PREPROCESSOR_LANGS[path.extname(filename).slice(1)];
+	const ext = path.extname(filename).slice(1);
+	return PREPROCESSOR_LANGS[ext];
 }
 function getPreprocessorLangFromId(id) {
 	const match = CSS_LANGS_RE.exec(id);
@@ -269,7 +270,7 @@ async function compileSass(lang, code, filename, options) {
 			};
 		}
 	};
-	const result = await sass.compileStringAsync(data, {
+	const result = await (await loadSassCompiler(sass)).compileStringAsync(data, {
 		url: pathToFileURL(filename),
 		sourceMap: false,
 		syntax: lang === "sass" ? "indented" : "scss",
@@ -307,6 +308,20 @@ async function tryResolveScss(url, importer) {
 	return resolveWithResolver(getSassResolver(), url, importer);
 }
 let _sass;
+let _sassCompiler;
+function loadSassCompiler(sass) {
+	if (!sass.initAsyncCompiler) return Promise.resolve(sass);
+	_sassCompiler ??= sass.initAsyncCompiler().catch((error) => {
+		_sassCompiler = void 0;
+		throw error;
+	});
+	return _sassCompiler;
+}
+async function disposeSassCompiler() {
+	const compilerPromise = _sassCompiler;
+	_sassCompiler = void 0;
+	await (await compilerPromise?.catch(() => void 0))?.dispose?.();
+}
 async function loadSass() {
 	if (_sass) return _sass;
 	try {
@@ -390,10 +405,13 @@ async function transformWithLightningCSS(code, filename, options) {
 		...options.lightningcss,
 		targets,
 		minify: options.minify,
-		cssModules: options.cssModules
+		cssModules: options.cssModules,
+		sourceMap: options.sourceMap,
+		inputSourceMap: options.inputSourceMap
 	});
 	return {
 		code: decoder.decode(result.code),
+		map: result.map ? decoder.decode(result.map) : void 0,
 		modules: result.exports ? extractLightningCssModuleExports(result.exports) : void 0
 	};
 }
@@ -407,6 +425,7 @@ async function bundleWithLightningCSS(filename, options, code) {
 		targets,
 		minify: options.minify,
 		cssModules: options.cssModules,
+		sourceMap: options.sourceMap,
 		resolver: {
 			async read(filePath) {
 				let fileCode;
@@ -431,8 +450,9 @@ async function bundleWithLightningCSS(filename, options, code) {
 		}
 	});
 	return {
-		code: new TextDecoder().decode(result.code),
+		code: decoder.decode(result.code),
 		deps,
+		map: result.map ? decoder.decode(result.map) : void 0,
 		modules: result.exports ? extractLightningCssModuleExports(result.exports) : void 0
 	};
 }
@@ -447,7 +467,7 @@ const ESBUILD_LIGHTNINGCSS_MAPPING = {
 	safari: "safari"
 };
 function parseVersion(version) {
-	const [major, minor = 0, patch = 0] = version.split("-")[0].split(".").map((v) => Number.parseInt(v, 10));
+	const [major, minor = 0, patch = 0] = version.split("-", 1)[0].split(".").map((v) => Number.parseInt(v, 10));
 	if (Number.isNaN(major) || Number.isNaN(minor) || Number.isNaN(patch)) return null;
 	return major << 16 | minor << 8 | patch;
 }
@@ -455,7 +475,8 @@ function esbuildTargetToLightningCSS(target) {
 	let targets;
 	const matches = [...target.join(" ").toLowerCase().matchAll(TARGET_REGEX)];
 	for (const match of matches) {
-		const browser = ESBUILD_LIGHTNINGCSS_MAPPING[match[1]];
+		const name = match[1];
+		const browser = ESBUILD_LIGHTNINGCSS_MAPPING[name];
 		if (!browser) continue;
 		const version = match[2];
 		const versionInt = parseVersion(version);
@@ -585,7 +606,7 @@ async function loadFileConfig(searchPath) {
 	if (cached !== void 0) return cached;
 	const promise = (async () => {
 		try {
-			const postcssrc = (await import("./src-CISfE_A0.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))).default;
+			const postcssrc = (await import("./src-BV-UJr_R.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1))).default;
 			const result = await postcssrc({}, searchPath);
 			return {
 				options: result.options,
@@ -611,7 +632,7 @@ function resolvePostCSSConfig(postcssOption, cwd) {
 	}
 	return loadFileConfig(typeof postcssOption === "string" ? postcssOption : cwd);
 }
-async function processWithPostCSS$1(code, filename, postcssOption, cwd, injectImport, modulesOptions) {
+async function processWithPostCSS$1(code, filename, postcssOption, cwd, injectImport, modulesOptions, sourceMap) {
 	const config = await resolvePostCSSConfig(postcssOption, cwd);
 	const plugins = [];
 	let modules;
@@ -638,7 +659,12 @@ async function processWithPostCSS$1(code, filename, postcssOption, cwd, injectIm
 	const result = await (await importWithError("postcss")).default(plugins).process(code, {
 		...config?.options,
 		from: filename,
-		to: filename
+		to: filename,
+		map: sourceMap ? {
+			inline: false,
+			annotation: false,
+			prev: false
+		} : void 0
 	});
 	const deps = [];
 	for (const message of result.messages) if (message.type === "dependency") deps.push(message.file);
@@ -649,6 +675,7 @@ async function processWithPostCSS$1(code, filename, postcssOption, cwd, injectIm
 	return {
 		code: result.css,
 		deps,
+		map: result.map?.toString(),
 		modules
 	};
 }
@@ -660,7 +687,8 @@ function CssPlugin(config, { logger }) {
 	const cssConfig = {
 		css: resolveCssOptions(config.css, config.target, config.unbundle),
 		cwd: config.cwd,
-		target: config.target
+		target: config.target,
+		sourceMap: Boolean(config.sourcemap)
 	};
 	const styles = /* @__PURE__ */ new Map();
 	const modulesMap = /* @__PURE__ */ new Map();
@@ -670,6 +698,12 @@ function CssPlugin(config, { logger }) {
 			styles.clear();
 			modulesMap.clear();
 		},
+		closeBundle() {
+			if (!this.meta.watchMode) return disposeSassCompiler();
+		},
+		closeWatcher() {
+			return disposeSassCompiler();
+		},
 		resolveId: {
 			filter: { id: RE_CSS_INLINE },
 			async handler(source, ...args) {
@@ -703,14 +737,17 @@ function CssPlugin(config, { logger }) {
 				const isModule = !RE_INLINE.test(id) && cssConfig.css.modules !== false && CSS_MODULE_RE.test(id);
 				const deps = [];
 				let modules;
+				let map;
 				if (cssConfig.css.transformer === "lightningcss") {
 					const result = await processWithLightningCSS(code, id, cleanId, deps, cssConfig, logger, isModule);
 					code = result.code;
 					modules = result.modules;
+					map = result.map;
 				} else {
 					const result = await processWithPostCSS(code, id, cleanId, deps, cssConfig, isModule);
 					code = result.code;
 					modules = result.modules;
+					map = result.map;
 				}
 				for (const dep of deps) this.addWatchFile(dep);
 				if (code.length && !code.endsWith("\n")) code += "\n";
@@ -720,7 +757,10 @@ function CssPlugin(config, { logger }) {
 					modulesConfig?.getJSON?.(cleanId, modules, cleanId);
 					modulesMap.set(id, modules);
 				}
-				return { code };
+				return {
+					code,
+					map: map ?? null
+				};
 			}
 		}
 	};
@@ -734,17 +774,20 @@ function CssPlugin(config, { logger }) {
 				const modules = modulesMap.get(id);
 				if (isInline) return {
 					code: `export default ${JSON.stringify(code)};`,
+					map: null,
 					moduleSideEffects: false,
 					moduleType: "js"
 				};
 				if (code.length) styles.set(id, code);
 				if (modules) return {
 					code: modulesToEsm(modules),
+					map: null,
 					moduleSideEffects: false,
 					moduleType: "js"
 				};
 				return {
 					code: "",
+					map: null,
 					moduleSideEffects: "no-treeshake",
 					moduleType: "js"
 				};
@@ -817,14 +860,16 @@ async function processWithLightningCSS(code, id, cleanId, deps, config, logger,
 			target: config.css.target,
 			lightningcss: config.css.lightningcss,
 			minify: config.css.minify,
-			cssModules
+			cssModules,
+			sourceMap: config.sourceMap
 		});
 	}
 	if (id !== cleanId && !RE_INLINE.test(id)) return transformWithLightningCSS(code, cleanId, {
 		target: config.css.target,
 		lightningcss: config.css.lightningcss,
 		minify: config.css.minify,
-		cssModules
+		cssModules,
+		sourceMap: config.sourceMap
 	});
 	if (RE_CSS.test(cleanId)) {
 		const bundleResult = await bundleWithLightningCSS(cleanId, {
@@ -833,11 +878,13 @@ async function processWithLightningCSS(code, id, cleanId, deps, config, logger,
 			minify: config.css.minify,
 			cssModules,
 			preprocessorOptions: config.css.preprocessorOptions,
+			sourceMap: config.sourceMap,
 			logger
 		}, code);
 		deps.push(...bundleResult.deps);
 		return {
 			code: bundleResult.code,
+			map: bundleResult.map,
 			modules: bundleResult.modules
 		};
 	}
@@ -855,15 +902,19 @@ async function processWithPostCSS(code, id, cleanId, deps, config, isModule) {
 	const postcssResult = await processWithPostCSS$1(code, cleanId, config.css.postcss, config.cwd, needInlineImport, isModule ? {
 		isModule: true,
 		config: modulesConfig
-	} : void 0);
+	} : void 0, config.sourceMap);
 	code = postcssResult.code;
 	deps.push(...postcssResult.deps);
+	const transformResult = await transformWithLightningCSS(code, cleanId, {
+		target: config.css.target,
+		lightningcss: config.css.lightningcss,
+		minify: config.css.minify,
+		sourceMap: config.sourceMap,
+		inputSourceMap: postcssResult.map
+	});
 	return {
-		code: (await transformWithLightningCSS(code, cleanId, {
-			target: config.css.target,
-			lightningcss: config.css.lightningcss,
-			minify: config.css.minify
-		})).code,
+		code: transformResult.code,
+		map: transformResult.map ?? postcssResult.map,
 		modules: postcssResult.modules
 	};
 }