weapp-tailwindcss 5.0.0-next.11 → 5.0.0-next.14

package/dist/{incremental-runtime-class-set-CBMefNHQ.js → incremental-runtime-class-set-B4EXHHii.js}

@@ -1,9 +1,9 @@
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_cache = require("./cache-B_9E7FxF.js");
-const require_runtime_patch = require("./runtime-patch-CqB-A4zA.js");
-const require_generator = require("./generator-Ck1Dd1V0.js");
-const require_precheck = require("./precheck-D5eEdqeH.js");
-const require_tailwindcss = require("./tailwindcss-B78nj6n7.js");
+const require_v3_engine = require("./v3-engine-DwV1E6rX.js");
+const require_generator = require("./generator-CRORPkpW.js");
+const require_precheck = require("./precheck-CZHcFX8k.js");
+const require_tailwindcss = require("./tailwindcss-CN0K7G-l.js");
+let node_fs = require("node:fs");
 let postcss = require("postcss");
 postcss = require_chunk.__toESM(postcss);
 let node_path = require("node:path");
@@ -11,7 +11,6 @@ node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 let tailwindcss_patch = require("tailwindcss-patch");
-let node_fs = require("node:fs");
 //#region src/bundlers/shared/generator-css/markers.ts
 const TAILWIND_V4_BANNER_RE = /\/\*!\s*tailwindcss v4\./;
 const TAILWIND_GENERATED_CSS_MARKER_RE = /\/\*!\s*tailwindcss v|@property\s+--tw-|--tw-|:not\(#\\#\)|\.[^,{]*(?:\\:|\\\[|\\#)|(?::host|page|\.tw-root|wx-root-portal-content)[^{]*\{[^}]*--(?:color|spacing|text|font-weight|radius)-/;
@@ -123,7 +122,7 @@ function normalizeTailwindImportAtRules(root, options = {}) {
 function normalizeTailwindDirectiveLine(line, options = {}) {
 	if (!options.importFallback || !line.trimStart().startsWith("@import")) return line;
 	const request = parseImportRequest(line.trimStart().replace(/^@import\b/, ""));
-	if (!isWeappTailwindcssImportRequest(request)) return line;
+	if (!request || !isWeappTailwindcssImportRequest(request)) return line;
 	return replaceImportRequest(line, request, request.replace(/^weapp-tailwindcss/, "tailwindcss"));
 }
 function extractTailwindDirectiveLines(rawSource, options = {}) {
@@ -570,6 +569,7 @@ const PREFLIGHT_RESET_PROPS = new Set([
 	"margin",
 	"padding"
 ]);
+const CONTENT_VAR_RE = /var\(\s*--tw-content\b/;
 function isMiniProgramThemeScopeSelector$1(selectors) {
 	return selectors.length > 0 && selectors.every((selector) => MINI_PROGRAM_THEME_SCOPE_SELECTORS$1.has(selector));
 }
@@ -602,6 +602,16 @@ function hasContentInitDeclaration(rule) {
 	});
 	return hasContentInit;
 }
+function isEmptyContentInitDeclaration(decl) {
+	return decl.prop === "--tw-content" && (decl.value === "\"\"" || decl.value === "''");
+}
+function usesTwContentVariable(root) {
+	let used = false;
+	root.walkDecls((decl) => {
+		if (CONTENT_VAR_RE.test(decl.value)) used = true;
+	});
+	return used;
+}
 function isTailwindPreflightRule(node) {
 	if (node.type !== "rule" || node.parent?.type !== "root") return false;
 	const rule = node;
@@ -620,7 +630,7 @@ function createPseudoContentInitRule() {
 	});
 	return rule;
 }
-function collectPreflightRules(root) {
+function collectPreflightRules(root, options = {}) {
 	const preflightNodes = [];
 	let hasContentInit = false;
 	for (const node of root.nodes ?? []) if (isTailwindPreflightRule(node)) {
@@ -629,20 +639,34 @@ function collectPreflightRules(root) {
 	}
 	if (preflightNodes.length === 0) return [];
 	const clonedPreflightRules = preflightNodes.map((node) => node.clone());
-	const contentInitRules = clonedPreflightRules.filter((rule) => hasContentInitDeclaration(rule));
+	const contentInitRules = options.preservePseudoContentInit ? clonedPreflightRules.filter((rule) => hasContentInitDeclaration(rule)) : [];
 	const otherPreflightRules = clonedPreflightRules.filter((rule) => !hasContentInitDeclaration(rule));
-	const preflightRules = hasContentInit ? [...contentInitRules, ...otherPreflightRules] : [createPseudoContentInitRule(), ...otherPreflightRules];
+	const preflightRules = hasContentInit ? [...contentInitRules, ...otherPreflightRules] : [...options.preservePseudoContentInit ? [createPseudoContentInitRule()] : [], ...otherPreflightRules];
 	for (const node of preflightNodes) node.remove();
 	return preflightRules;
 }
-function collectThemeVariableRule(root) {
+function createPreflightResetRule(cssPreflight) {
+	if (!cssPreflight || typeof cssPreflight !== "object") return;
+	const rule = postcss.default.rule({ selector: "view,text,:after,:before" });
+	for (const [prop, value] of Object.entries(cssPreflight)) {
+		if (value === false) continue;
+		rule.append({
+			prop,
+			value: value.toString()
+		});
+	}
+	return rule.nodes?.length ? rule : void 0;
+}
+function collectThemeVariableRule(root, options = {}) {
 	const themeRules = [];
 	const declarations = /* @__PURE__ */ new Map();
+	const shouldPreserveContentInit = options.preservePseudoContentInit || usesTwContentVariable(root);
 	for (const node of root.nodes ?? []) {
 		if (!isMiniProgramThemeVariableRule(node)) continue;
 		themeRules.push(node);
 		node.walkDecls((decl) => {
 			if (isDisplayP3Declaration(decl)) return;
+			if (!shouldPreserveContentInit && isEmptyContentInitDeclaration(decl)) return;
 			declarations.set(decl.prop, decl.clone());
 		});
 	}
@@ -672,8 +696,8 @@ function insertHoistedRules(root, rules) {
 	if (topDirectiveTail) topDirectiveTail.after(rules);
 	else root.prepend(rules);
 }
-function finalizeMiniProgramCssRoot(root) {
-	require_generator.removeUnsupportedCascadeLayers(root);
+function finalizeMiniProgramCssRoot(root, options = {}) {
+	require_v3_engine.removeUnsupportedCascadeLayers(root);
 	unwrapTailwindSourceMedia(root);
 	root.walkAtRules("property", (atRule) => {
 		atRule.remove();
@@ -681,8 +705,12 @@ function finalizeMiniProgramCssRoot(root) {
 	removeSpecificityPlaceholders(root);
 	removeUnsupportedBrowserSelectors(root);
 	removeDisplayP3Declarations(root);
-	const preflightRules = collectPreflightRules(root);
-	const themeRule = collectThemeVariableRule(root);
+	const preflightRules = collectPreflightRules(root, options);
+	if (preflightRules.length === 0) {
+		const resetRule = createPreflightResetRule(options.cssPreflight);
+		if (resetRule) preflightRules.push(resetRule);
+	}
+	const themeRule = collectThemeVariableRule(root, options);
 	insertHoistedRules(root, themeRule ? [...preflightRules, themeRule] : preflightRules);
 }
 function unwrapTailwindSourceMedia(root) {
@@ -690,11 +718,11 @@ function unwrapTailwindSourceMedia(root) {
 		if (atRule.params.startsWith("source(") && atRule.nodes && atRule.nodes.length > 0) atRule.replaceWith(...atRule.nodes);
 	});
 }
-function finalizeMiniProgramCss(css) {
+function finalizeMiniProgramCss(css, options = {}) {
 	const cleanedCss = removeUnsupportedMiniProgramAtRules(css);
 	try {
 		const root = postcss.default.parse(cleanedCss);
-		finalizeMiniProgramCssRoot(root);
+		finalizeMiniProgramCssRoot(root, options);
 		return root.toString();
 	} catch {
 		return cleanedCss;
@@ -710,6 +738,15 @@ const MINI_PROGRAM_THEME_SCOPE_SELECTORS = new Set([
 	"wx-root-portal-content"
 ]);
 const SPECIFICITY_PLACEHOLDER_RE = /:not\(#(?:\\#|n)\)/g;
+const SELECTOR_CACHE_LIMIT = 64;
+const generatedSelectorCache = /* @__PURE__ */ new Map();
+function setGeneratedSelectorCache(css, selectors) {
+	if (generatedSelectorCache.size >= SELECTOR_CACHE_LIMIT) {
+		const firstKey = generatedSelectorCache.keys().next().value;
+		if (firstKey !== void 0) generatedSelectorCache.delete(firstKey);
+	}
+	generatedSelectorCache.set(css, selectors);
+}
 function normalizeCompatSelector(selector) {
 	return selector.replace(SPECIFICITY_PLACEHOLDER_RE, "").replace(/\s+/g, " ").trim();
 }
@@ -805,6 +842,8 @@ function isPseudoContentInitRule(rule) {
 	return hasDeclaration && onlyContentVariable;
 }
 function collectGeneratedSelectors(css) {
+	const cached = generatedSelectorCache.get(css);
+	if (cached) return cached;
 	const selectors = /* @__PURE__ */ new Set();
 	try {
 		postcss.default.parse(css).walkRules((rule) => {
@@ -814,8 +853,30 @@ function collectGeneratedSelectors(css) {
 	} catch {
 		return selectors;
 	}
+	setGeneratedSelectorCache(css, selectors);
 	return selectors;
 }
+function collectGeneratedDeclarationPropsBySelector(generatedCss, selectors) {
+	const propsBySelector = /* @__PURE__ */ new Map();
+	try {
+		postcss.default.parse(generatedCss).walkRules((rule) => {
+			const matchedSelectors = getRuleCompatSelectorKeys(rule).filter((selector) => selectors.has(selector));
+			if (matchedSelectors.length === 0) return;
+			const props = /* @__PURE__ */ new Set();
+			rule.walkDecls((decl) => {
+				props.add(decl.prop);
+			});
+			for (const selector of matchedSelectors) {
+				const existing = propsBySelector.get(selector);
+				if (existing) for (const prop of props) existing.add(prop);
+				else propsBySelector.set(selector, new Set(props));
+			}
+		});
+	} catch {
+		return propsBySelector;
+	}
+	return propsBySelector;
+}
 function removeGeneratedSelectorCompatCss(css, generatedCss) {
 	const generatedSelectors = collectGeneratedSelectors(generatedCss);
 	if (generatedSelectors.size === 0) return css;
@@ -845,23 +906,27 @@ function removeGeneratedSelectorCompatCss(css, generatedCss) {
 function collectDedupedPostTransformCompatCss(css, generatedCss) {
 	const generatedSelectors = collectGeneratedSelectors(generatedCss);
 	if (generatedSelectors.size === 0) return css;
+	const generatedDeclarationPropsBySelector = collectGeneratedDeclarationPropsBySelector(generatedCss, generatedSelectors);
 	const preservedNodes = [];
 	try {
 		const root = postcss.default.parse(css);
 		root.each((node) => {
-			if (node.type === "rule" && getRuleCompatSelectorKeys(node).some((selector) => generatedSelectors.has(selector))) {
+			if (node.type === "rule") {
+				const nodeSelectors = getRuleCompatSelectorKeys(node);
+				if (!nodeSelectors.some((selector) => generatedSelectors.has(selector))) {
+					preservedNodes.push(node.clone());
+					return;
+				}
 				if (isCustomPropertyOnlyRule(node) && !isPseudoContentInitRule(node) && !hasUtilityClassSelector(node.selector)) {
 					const declarationProps = /* @__PURE__ */ new Set();
 					node.walkDecls((decl) => {
 						declarationProps.add(decl.prop);
 					});
-					postcss.default.parse(generatedCss).walkRules((rule) => {
-						const nodeSelectors = new Set(getRuleCompatSelectorKeys(node));
-						if (!getRuleCompatSelectorKeys(rule).some((selector) => nodeSelectors.has(selector))) return;
-						rule.walkDecls((decl) => {
-							declarationProps.delete(decl.prop);
-						});
-					});
+					for (const selector of nodeSelectors) {
+						const generatedProps = generatedDeclarationPropsBySelector.get(selector);
+						if (!generatedProps) continue;
+						for (const prop of generatedProps) declarationProps.delete(prop);
+					}
 					const nextRule = node.clone();
 					nextRule.walkDecls((decl) => {
 						if (!declarationProps.has(decl.prop)) decl.remove();
@@ -929,28 +994,24 @@ function createSourceStylePathCandidates(file, sourceOptions) {
 		sourceOptions.cwd,
 		node_process.default.cwd()
 	].filter((item) => typeof item === "string" && item.length > 0);
+	const outputRoots = [sourceOptions.outputRoot].filter((item) => typeof item === "string" && item.length > 0);
 	const strippedFile = stripStyleExtension(file);
 	const relativeFiles = /* @__PURE__ */ new Set();
-	if (node_path.default.isAbsolute(strippedFile)) for (const base of bases) {
-		const relative = node_path.default.relative(base, strippedFile);
-		if (!relative || relative.startsWith("..") || node_path.default.isAbsolute(relative)) continue;
-		relativeFiles.add(relative);
-		const parts = relative.split(node_path.default.sep).filter(Boolean);
-		if (parts.length > 1) {
-			relativeFiles.add(parts.slice(1).join(node_path.default.sep));
-			const distIndex = parts.lastIndexOf("dist");
-			if (distIndex >= 0 && distIndex < parts.length - 1) relativeFiles.add([...parts.slice(0, distIndex), ...parts.slice(distIndex + 1)].join(node_path.default.sep));
+	const addOutputRelativePath = (absoluteFile) => {
+		for (const outputRoot of outputRoots) {
+			const relative = node_path.default.relative(outputRoot, absoluteFile);
+			if (!relative || relative.startsWith("..") || node_path.default.isAbsolute(relative)) continue;
+			relativeFiles.add(relative);
 		}
-	}
-	else {
-		relativeFiles.add(strippedFile);
-		const parts = strippedFile.split(/[\\/]/).filter(Boolean);
-		if (parts.length > 1) {
-			relativeFiles.add(parts.slice(1).join(node_path.default.sep));
-			const distIndex = parts.lastIndexOf("dist");
-			if (distIndex >= 0 && distIndex < parts.length - 1) relativeFiles.add([...parts.slice(0, distIndex), ...parts.slice(distIndex + 1)].join(node_path.default.sep));
+	};
+	if (node_path.default.isAbsolute(strippedFile)) {
+		addOutputRelativePath(strippedFile);
+		for (const base of bases) {
+			const relative = node_path.default.relative(base, strippedFile);
+			if (!relative || relative.startsWith("..") || node_path.default.isAbsolute(relative)) continue;
+			relativeFiles.add(relative);
 		}
-	}
+	} else relativeFiles.add(strippedFile);
 	const candidates = /* @__PURE__ */ new Set();
 	for (const relativeFile of relativeFiles) {
 		if (!relativeFile || node_path.default.isAbsolute(relativeFile)) continue;
@@ -980,7 +1041,10 @@ function resolveSourceSideCssEntrySource(file, sourceOptions, resolveOptions = {
 			const source = (0, node_fs.readFileSync)(sourceFile, "utf8");
 			for (const styleSource of extractStyleDirectiveSources(source)) {
 				const cssEntrySource = resolveCssEntrySource(styleSource, node_path.default.dirname(sourceFile), resolveOptions);
-				if (cssEntrySource) return cssEntrySource;
+				if (cssEntrySource) return {
+					...cssEntrySource,
+					file: sourceFile
+				};
 			}
 		} catch {
 			continue;
@@ -993,6 +1057,25 @@ function resolvePostcssFromOption(cssHandlerOptions) {
 	const from = cssHandlerOptions.postcssOptions?.options?.from;
 	return typeof from === "string" && from.length > 0 ? from : void 0;
 }
+function resolvePostcssSourceFile(cssHandlerOptions) {
+	const from = resolvePostcssFromOption(cssHandlerOptions);
+	if (!from || !node_path.default.isAbsolute(from)) return;
+	return from.replace(/[?#].*$/, "");
+}
+function resolveCssHandlerSourceOptions(cssHandlerOptions) {
+	return cssHandlerOptions.sourceOptions;
+}
+function createSingleTailwindV4SourceOptions(sourceOptions, options) {
+	return require_v3_engine.omitUndefined({
+		projectRoot: sourceOptions.projectRoot,
+		baseFallbacks: sourceOptions.baseFallbacks,
+		sources: sourceOptions.sources,
+		packageName: sourceOptions.packageName,
+		outputRoot: sourceOptions.outputRoot,
+		base: options.base,
+		css: options.css
+	});
+}
 function resolveCssSourceBase(file, cssHandlerOptions) {
 	const normalized = (resolvePostcssFromOption(cssHandlerOptions) ?? file).replace(/[?#].*$/, "");
 	return node_path.default.dirname(node_path.default.resolve(normalized));
@@ -1023,7 +1106,10 @@ function canResolveSourceSideCssEntry(file, cssHandlerOptions) {
 	return true;
 }
 function shouldResolveSourceSideCssEntry(rawSource) {
-	return rawSource.includes("@apply");
+	return rawSource.includes("@apply") || hasTailwindGeneratedCss(rawSource) || hasTailwindGeneratedCssMarkers(rawSource);
+}
+function shouldPreferTailwindV3SourceSideEntry(rawSource, sourceSideEntrySource) {
+	return Boolean(sourceSideEntrySource) && !hasTailwindSourceDirectives(rawSource, { importFallback: true });
 }
 function normalizeCssSourceForCompare(css) {
 	return stripGeneratorPlaceholderMarkers(stripTailwindBanners(css)).trim();
@@ -1032,6 +1118,27 @@ function getOutputFileStem(file) {
 	const normalized = file.replace(/[?#].*$/, "");
 	return node_path.default.basename(normalized, node_path.default.extname(normalized));
 }
+function getOutputFileWithoutExtension(file) {
+	const normalized = file.replace(/[?#].*$/, "");
+	const ext = node_path.default.extname(normalized);
+	return ext ? normalized.slice(0, -ext.length) : normalized;
+}
+function normalizeMatchPath(file) {
+	return file.split(node_path.default.sep).join("/");
+}
+function stripKnownBuildRootPrefix(file) {
+	const segments = normalizeMatchPath(file).split("/");
+	const knownRoots = new Set(["dist", "src"]);
+	for (let index = segments.length - 1; index >= 0; index--) if (knownRoots.has(segments[index])) return segments.slice(index + 1).join("/");
+	return segments.join("/");
+}
+function isMatchingTailwindV4CssSourceFile(file, cssSourceFile) {
+	const outputBase = normalizeMatchPath(getOutputFileWithoutExtension(node_path.default.resolve(file)));
+	const sourceBase = normalizeMatchPath(getOutputFileWithoutExtension(node_path.default.resolve(cssSourceFile)));
+	const outputRelativeBase = stripKnownBuildRootPrefix(outputBase);
+	const sourceRelativeBase = stripKnownBuildRootPrefix(sourceBase);
+	return outputBase === sourceBase || outputBase.endsWith(`/${sourceBase}`) || sourceBase.endsWith(`/${outputBase}`) || outputRelativeBase.length > 0 && outputRelativeBase === sourceRelativeBase;
+}
 function resolveMatchingTailwindV4CssEntry(rawSource, file, sourceOptions) {
 	const cssEntries = sourceOptions.cssEntries;
 	if (!cssEntries?.length) return;
@@ -1047,14 +1154,28 @@ function resolveMatchingTailwindV4CssEntry(rawSource, file, sourceOptions) {
 		}
 	});
 	if (!matchingEntry) return;
-	return require_generator.resolveTailwindV4Source({
-		...require_cache.omitUndefined(sourceOptions),
+	return require_v3_engine.resolveTailwindV4Source({
+		...require_v3_engine.omitUndefined(sourceOptions),
 		cssEntries: [matchingEntry]
 	});
 }
+async function resolveMatchingTailwindV4CssSource(rawSource, file, cssHandlerOptions, sourceOptions) {
+	const cssSources = sourceOptions.cssSources;
+	if (!cssSources?.length) return;
+	const normalizedRawSource = normalizeCssSourceForCompare(rawSource);
+	const sourceFile = resolvePostcssSourceFile(cssHandlerOptions);
+	const matchingSource = cssSources.find((cssSource) => {
+		if (typeof cssSource.css !== "string" || cssSource.css.length === 0) return false;
+		if (sourceFile && typeof cssSource.file === "string" && node_path.default.resolve(sourceFile) === node_path.default.resolve(cssSource.file)) return true;
+		if (typeof cssSource.file === "string" && isMatchingTailwindV4CssSourceFile(file, cssSource.file)) return true;
+		return normalizeCssSourceForCompare(cssSource.css) === normalizedRawSource;
+	});
+	if (!matchingSource) return;
+	return resolveSingleTailwindV4CssSource(matchingSource, sourceOptions);
+}
 function tryResolveTailwindV4SourceOptions(runtimeState) {
 	try {
-		return require_generator.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher);
+		return require_v3_engine.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher);
 	} catch {
 		return;
 	}
@@ -1062,26 +1183,119 @@ function tryResolveTailwindV4SourceOptions(runtimeState) {
 function hasConfiguredTailwindV4CssSource(sourceOptions) {
 	return Boolean(sourceOptions?.css) || Boolean(sourceOptions?.cssSources?.length);
 }
+function resolveTailwindV4CssSourceBase(cssSource, fallbackBase) {
+	if (typeof cssSource.base === "string" && cssSource.base.length > 0) return cssSource.base;
+	if (typeof cssSource.file === "string" && cssSource.file.length > 0) return node_path.default.dirname(cssSource.file);
+	return fallbackBase;
+}
+async function resolveSingleTailwindV4CssSource(cssSource, sourceOptions) {
+	const source = await require_v3_engine.resolveTailwindV4Source({
+		...require_v3_engine.omitUndefined(sourceOptions),
+		cssSources: [cssSource]
+	});
+	const sourceBaseFallback = sourceOptions.base ?? sourceOptions.projectRoot ?? node_process.default.cwd();
+	return withGeneratorSourceMetadata(source, {
+		matchedCssSourceFile: typeof cssSource.file === "string" ? cssSource.file : void 0,
+		sourceBase: resolveTailwindV4CssSourceBase(cssSource, sourceBaseFallback),
+		sourceCss: cssSource.css
+	});
+}
+async function resolveTailwindV4CssSourceEntries(cssSource, sourceOptions) {
+	if (typeof cssSource.css !== "string" || cssSource.css.length === 0) return;
+	const sourceBase = resolveTailwindV4CssSourceBase(cssSource, sourceOptions.base ?? sourceOptions.projectRoot ?? node_process.default.cwd());
+	return require_v3_engine.resolveTailwindV4EntriesFromCss(cssSource.css, sourceBase);
+}
+function countRuntimeCandidateHits(candidates, runtime) {
+	if (!runtime?.size) return 0;
+	let hits = 0;
+	for (const candidate of candidates) if (runtime.has(candidate)) hits += 1;
+	return hits;
+}
+async function resolveCandidateMatchedTailwindV4CssSource(_rawSource, cssHandlerOptions, sourceOptions, selectionOptions) {
+	const cssSources = sourceOptions.cssSources;
+	const getSourceCandidatesForEntries = selectionOptions?.getSourceCandidatesForEntries;
+	if (!cssHandlerOptions.isMainChunk || !cssSources?.length || !getSourceCandidatesForEntries) return;
+	const matches = [];
+	await Promise.all(cssSources.map(async (cssSource, index) => {
+		const resolved = await resolveTailwindV4CssSourceEntries(cssSource, sourceOptions);
+		if (resolved?.entries === void 0) return;
+		const scopedCandidates = getSourceCandidatesForEntries(resolved?.entries);
+		const runtimeHits = countRuntimeCandidateHits(scopedCandidates, selectionOptions?.runtime);
+		if (runtimeHits === 0) return;
+		matches.push({
+			cssSource,
+			index,
+			runtimeHits,
+			totalCandidates: scopedCandidates.size
+		});
+	}));
+	if (matches.length === 0) return;
+	matches.sort((a, b) => b.runtimeHits - a.runtimeHits || b.totalCandidates - a.totalCandidates || a.index - b.index);
+	const best = matches[0];
+	const second = matches[1];
+	if (!best) return;
+	if (second && second.runtimeHits === best.runtimeHits && second.totalCandidates === best.totalCandidates) return;
+	return resolveSingleTailwindV4CssSource(best.cssSource, sourceOptions);
+}
+function createTailwindV4CssSourceResolver(sourceOptions, generatorOptions) {
+	return (cssSource) => require_v3_engine.resolveTailwindV4Source({
+		...require_v3_engine.omitUndefined(sourceOptions),
+		cssSources: [cssSource]
+	}).then((source) => generatorOptions?.config ? {
+		...source,
+		css: prependConfigDirective(source.css, generatorOptions.config)
+	} : source);
+}
+async function resolveTailwindV4SourceSideEntrySource(resolvedEntrySource, sourceOptions, generatorOptions, file) {
+	if (!resolvedEntrySource) return;
+	const resolvedSourceOptions = require_v3_engine.omitUndefined(sourceOptions);
+	const config = resolveExistingConfigPath(resolvedEntrySource.config, resolvedEntrySource.configRequest, file, resolvedSourceOptions);
+	const css = createTailwindV4ApplyReferenceSource(normalizeConfigDirective(prependConfigDirective(resolvedEntrySource.css, generatorOptions?.config), config), resolvedSourceOptions);
+	return withMatchedSourceSideMetadata(await require_v3_engine.resolveTailwindV4Source(createSingleTailwindV4SourceOptions(resolvedSourceOptions, {
+		base: resolvedEntrySource.base,
+		css
+	})), resolvedEntrySource);
+}
+function withGeneratorSourceMetadata(source, metadata) {
+	return {
+		...source,
+		__weappTailwindcssMeta: metadata
+	};
+}
+function withMatchedSourceSideMetadata(source, resolvedEntrySource) {
+	return resolvedEntrySource.file ? withGeneratorSourceMetadata(source, {
+		matchedCssSourceFile: resolvedEntrySource.file,
+		sourceBase: resolvedEntrySource.base,
+		sourceCss: resolvedEntrySource.css
+	}) : source;
+}
 function createTailwindV4ApplyReferenceSource(css, sourceOptions) {
 	if (!hasTailwindApplyDirective(css) || hasTailwindRootDirectives(css)) return css;
 	return `@reference "${sourceOptions.packageName ?? "tailwindcss"}";\n${css}`;
 }
-async function resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions) {
-	const cssEntrySource = resolveCssEntrySource(rawSource, resolveCssSourceBase(file, cssHandlerOptions), {
+async function resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions) {
+	const base = resolveCssSourceBase(file, cssHandlerOptions);
+	const cssEntrySource = resolveCssEntrySource(rawSource, base, {
 		importFallback: generatorOptions?.importFallback ?? false,
 		removeConfig: majorVersion === 3
 	});
 	if (majorVersion === 3) {
-		const sourceOptions = require_generator.resolveTailwindV3SourceOptionsFromPatcher(runtimeState.twPatcher);
-		const mergedSourceOptions = require_cache.omitUndefined({
+		const sourceOptions = require_v3_engine.resolveTailwindV3SourceOptionsFromPatcher(runtimeState.twPatcher);
+		const mergedSourceOptions = require_v3_engine.omitUndefined({
 			...sourceOptions,
-			config: generatorOptions?.config ?? sourceOptions.config
+			config: generatorOptions?.config ?? sourceOptions.config,
+			...resolveCssHandlerSourceOptions(cssHandlerOptions)
 		});
+		const applyEntrySource = hasTailwindApplyDirective(rawSource) ? {
+			base,
+			css: rawSource
+		} : void 0;
 		const sourceSideEntrySource = canResolveSourceSideCssEntry(file, cssHandlerOptions) ? resolveSourceSideCssEntrySource(file, mergedSourceOptions, { removeConfig: true }) : void 0;
-		const resolvedEntrySource = cssEntrySource ?? sourceSideEntrySource;
-		if (!resolvedEntrySource) return generatorOptions?.config ? require_generator.resolveTailwindV3Source(mergedSourceOptions) : require_generator.resolveTailwindV3SourceFromPatcher(runtimeState.twPatcher);
-		const config = resolveExistingConfigPath(resolvedEntrySource.config, resolvedEntrySource.configRequest, file, require_cache.omitUndefined(mergedSourceOptions));
-		return require_generator.resolveTailwindV3Source({
+		const resolvedEntrySource = shouldResolveSourceSideCssEntry(rawSource) ? applyEntrySource ?? cssEntrySource ?? sourceSideEntrySource : shouldPreferTailwindV3SourceSideEntry(rawSource, sourceSideEntrySource) ? sourceSideEntrySource ?? cssEntrySource : cssEntrySource ?? applyEntrySource ?? sourceSideEntrySource;
+		if (!resolvedEntrySource) return generatorOptions?.config ? require_v3_engine.resolveTailwindV3Source(mergedSourceOptions) : require_v3_engine.resolveTailwindV3SourceFromPatcher(runtimeState.twPatcher);
+		if (cssEntrySource && !sourceSideEntrySource && !applyEntrySource && !hasTailwindRootDirectives(rawSource, { importFallback: true })) return generatorOptions?.config ? require_v3_engine.resolveTailwindV3Source(mergedSourceOptions) : require_v3_engine.resolveTailwindV3SourceFromPatcher(runtimeState.twPatcher);
+		const config = resolveExistingConfigPath(resolvedEntrySource.config, resolvedEntrySource.configRequest, file, require_v3_engine.omitUndefined(mergedSourceOptions));
+		return require_v3_engine.resolveTailwindV3Source({
 			...mergedSourceOptions,
 			base: resolvedEntrySource.base,
 			css: resolvedEntrySource.css,
@@ -1089,60 +1303,104 @@ async function resolveGeneratorSource(majorVersion, runtimeState, rawSource, fil
 		});
 	}
 	const sourceOptions = tryResolveTailwindV4SourceOptions(runtimeState);
-	const configuredCssSource = sourceOptions && hasConfiguredTailwindV4CssSource(sourceOptions) && hasTailwindGeneratedCssMarkers(rawSource) ? await require_generator.resolveTailwindV4Source(sourceOptions) : void 0;
+	const resolvedSourceOptions = sourceOptions ? require_v3_engine.omitUndefined({
+		...sourceOptions,
+		...resolveCssHandlerSourceOptions(cssHandlerOptions)
+	}) : void 0;
+	const shouldPreferSourceSideEntry = shouldResolveSourceSideCssEntry(rawSource) || Boolean(cssEntrySource?.css.includes("weapp-tailwindcss generator-placeholder"));
+	const sourceSideEntrySource = resolvedSourceOptions && shouldPreferSourceSideEntry ? resolveSourceSideCssEntrySource(file, resolvedSourceOptions, { removeConfig: false }) : void 0;
+	const matchedCssSource = sourceOptions ? await resolveMatchingTailwindV4CssSource(rawSource, file, cssHandlerOptions, sourceOptions) : void 0;
+	const candidateMatchedCssSource = sourceOptions ? await resolveCandidateMatchedTailwindV4CssSource(rawSource, cssHandlerOptions, sourceOptions, selectionOptions) : void 0;
+	const configuredCssSource = sourceOptions && hasConfiguredTailwindV4CssSource(sourceOptions) && hasTailwindGeneratedCssMarkers(rawSource) ? matchedCssSource ?? candidateMatchedCssSource ?? await require_v3_engine.resolveTailwindV4Source(sourceOptions) : void 0;
 	if (configuredCssSource) return generatorOptions?.config ? {
 		...configuredCssSource,
 		css: prependConfigDirective(configuredCssSource.css, generatorOptions.config)
 	} : configuredCssSource;
-	const shouldPreferSourceSideEntry = shouldResolveSourceSideCssEntry(rawSource) || Boolean(cssEntrySource?.css.includes("weapp-tailwindcss generator-placeholder"));
-	const sourceSideEntrySource = sourceOptions && shouldPreferSourceSideEntry ? resolveSourceSideCssEntrySource(file, sourceOptions, { removeConfig: false }) : void 0;
 	const matchedCssEntrySource = sourceOptions && cssEntrySource ? await resolveMatchingTailwindV4CssEntry(rawSource, file, sourceOptions) : void 0;
-	const mainCssEntrySource = sourceOptions && cssHandlerOptions.isMainChunk && sourceOptions.cssEntries?.length === 1 ? await require_generator.resolveTailwindV4Source({
-		...require_cache.omitUndefined(sourceOptions),
+	const mainCssEntrySource = sourceOptions && cssHandlerOptions.isMainChunk && sourceOptions.cssEntries?.length === 1 ? await require_v3_engine.resolveTailwindV4Source({
+		...require_v3_engine.omitUndefined(sourceOptions),
 		cssEntries: [sourceOptions.cssEntries[0]]
 	}) : void 0;
-	const preferredCssEntrySource = matchedCssEntrySource ?? mainCssEntrySource;
+	const preferredCssEntrySource = matchedCssEntrySource ?? matchedCssSource ?? candidateMatchedCssSource ?? mainCssEntrySource;
 	if (preferredCssEntrySource) return generatorOptions?.config ? {
 		...preferredCssEntrySource,
 		css: prependConfigDirective(preferredCssEntrySource.css, generatorOptions.config)
 	} : preferredCssEntrySource;
 	const resolvedEntrySource = sourceSideEntrySource ?? cssEntrySource;
 	if (!resolvedEntrySource) {
-		const source = await require_generator.resolveTailwindV4SourceFromPatcher(runtimeState.twPatcher);
+		const source = await require_v3_engine.resolveTailwindV4SourceFromPatcher(runtimeState.twPatcher);
 		return generatorOptions?.config ? {
 			...source,
 			css: prependConfigDirective(source.css, generatorOptions.config)
 		} : source;
 	}
-	const resolvedSourceOptions = require_cache.omitUndefined(sourceOptions ?? {});
-	const config = resolveExistingConfigPath(resolvedEntrySource.config, resolvedEntrySource.configRequest, file, resolvedSourceOptions);
-	const css = createTailwindV4ApplyReferenceSource(normalizeConfigDirective(prependConfigDirective(resolvedEntrySource.css, generatorOptions?.config), config), resolvedSourceOptions);
-	return require_generator.resolveTailwindV4Source({
-		...resolvedSourceOptions,
+	if (sourceSideEntrySource && resolvedSourceOptions) return resolveTailwindV4SourceSideEntrySource(sourceSideEntrySource, resolvedSourceOptions, generatorOptions, file);
+	const config = resolveExistingConfigPath(resolvedEntrySource.config, resolvedEntrySource.configRequest, file, resolvedSourceOptions ?? {});
+	const css = createTailwindV4ApplyReferenceSource(normalizeConfigDirective(prependConfigDirective(resolvedEntrySource.css, generatorOptions?.config), config), resolvedSourceOptions ?? {});
+	return require_v3_engine.resolveTailwindV4Source(createSingleTailwindV4SourceOptions(resolvedSourceOptions ?? {}, {
 		base: resolvedEntrySource.base,
 		css
-	});
+	}));
 }
-async function resolveGeneratorSources(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions) {
+async function resolveGeneratorSources(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions) {
 	const cssEntrySource = resolveCssEntrySource(rawSource, resolveCssSourceBase(file, cssHandlerOptions), {
 		importFallback: generatorOptions?.importFallback ?? false,
 		removeConfig: majorVersion === 3
 	});
-	if (majorVersion !== 4 || cssEntrySource && !cssHandlerOptions.isMainChunk) return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions)];
+	if (majorVersion !== 4 || cssEntrySource && !cssHandlerOptions.isMainChunk) return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions)];
 	let sourceOptions;
 	try {
-		sourceOptions = require_generator.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher);
+		sourceOptions = require_v3_engine.omitUndefined({
+			...require_v3_engine.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher),
+			...resolveCssHandlerSourceOptions(cssHandlerOptions)
+		});
 	} catch {
-		return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions)];
+		return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions)];
 	}
-	if (!sourceOptions.cssEntries || sourceOptions.cssEntries.length <= 1) return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions)];
-	return await Promise.all(sourceOptions.cssEntries.map((cssEntry) => require_generator.resolveTailwindV4Source({
-		...require_cache.omitUndefined(sourceOptions),
+	const matchedCssEntrySource = cssEntrySource ? await resolveMatchingTailwindV4CssEntry(rawSource, file, sourceOptions) : void 0;
+	const matchedCssSource = await resolveMatchingTailwindV4CssSource(rawSource, file, cssHandlerOptions, sourceOptions);
+	const candidateMatchedCssSource = await resolveCandidateMatchedTailwindV4CssSource(rawSource, cssHandlerOptions, sourceOptions, selectionOptions);
+	const sourceSideCssSource = await resolveTailwindV4SourceSideEntrySource(shouldResolveSourceSideCssEntry(rawSource) || Boolean(cssEntrySource?.css.includes("weapp-tailwindcss generator-placeholder")) ? resolveSourceSideCssEntrySource(file, sourceOptions, { removeConfig: false }) : void 0, sourceOptions, generatorOptions, file);
+	const preferredCssEntrySource = matchedCssEntrySource ?? matchedCssSource ?? candidateMatchedCssSource;
+	if (sourceSideCssSource) return [sourceSideCssSource];
+	if (preferredCssEntrySource) return [generatorOptions?.config ? {
+		...preferredCssEntrySource,
+		css: prependConfigDirective(preferredCssEntrySource.css, generatorOptions.config)
+	} : preferredCssEntrySource];
+	if (!sourceOptions.cssEntries || sourceOptions.cssEntries.length <= 1) {
+		if (sourceOptions.cssSources?.length === 1) return [await createTailwindV4CssSourceResolver(sourceOptions, generatorOptions)(sourceOptions.cssSources[0])];
+		return [await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions)];
+	}
+	const cssEntrySources = await Promise.all(sourceOptions.cssEntries.map((cssEntry) => require_v3_engine.resolveTailwindV4Source({
+		...require_v3_engine.omitUndefined(sourceOptions),
 		cssEntries: [cssEntry]
 	}).then((source) => generatorOptions?.config ? {
 		...source,
 		css: prependConfigDirective(source.css, generatorOptions.config)
 	} : source)));
+	const cssSources = sourceOptions.cssSources?.length ? await Promise.all(sourceOptions.cssSources.map(createTailwindV4CssSourceResolver(sourceOptions, generatorOptions))) : [];
+	return [...cssEntrySources, ...cssSources];
+}
+async function resolveGeneratorSourceEntries(source, runtimeState) {
+	if (!("css" in source) || !("base" in source) || !("baseFallbacks" in source)) return;
+	const sourceMetadata = source.__weappTailwindcssMeta;
+	const resolved = await require_v3_engine.resolveTailwindV4EntriesFromCss(sourceMetadata?.sourceCss ?? source.css, sourceMetadata?.sourceBase ?? source.base);
+	if (resolved?.entries.length || !resolved?.explicit && !sourceMetadata?.matchedCssSourceFile || !runtimeState) return resolved?.entries;
+	const matchingCssSource = tryResolveTailwindV4SourceOptions(runtimeState)?.cssSources?.find((cssSource) => {
+		if (sourceMetadata?.matchedCssSourceFile && typeof cssSource.file === "string" && node_path.default.resolve(cssSource.file) === node_path.default.resolve(sourceMetadata.matchedCssSourceFile)) return true;
+		return cssSource.css === source.css;
+	});
+	if (!matchingCssSource) return resolved?.entries;
+	const sourceResolved = await require_v3_engine.resolveTailwindV4EntriesFromCss(matchingCssSource.css, typeof matchingCssSource.base === "string" && matchingCssSource.base.length > 0 ? matchingCssSource.base : typeof matchingCssSource.file === "string" && matchingCssSource.file.length > 0 ? node_path.default.dirname(matchingCssSource.file) : source.base);
+	if (sourceResolved?.entries.length) return sourceResolved.entries;
+	for (const dependency of matchingCssSource.dependencies ?? []) {
+		if (!(0, node_fs.existsSync)(dependency)) continue;
+		try {
+			const dependencyResolved = await require_v3_engine.resolveTailwindV4EntriesFromCss((0, node_fs.readFileSync)(dependency, "utf8"), node_path.default.dirname(dependency));
+			if (dependencyResolved?.entries.length) return dependencyResolved.entries;
+		} catch {}
+	}
+	return resolved.entries;
 }
 //#endregion
 //#region src/bundlers/shared/generator-css/legacy-compat.ts
@@ -1176,6 +1434,28 @@ const LEGACY_CONTAINER_COMPAT_CSS = [
 	"  }",
 	"}"
 ].join("\n");
+const LEGACY_COMPAT_CACHE_LIMIT = 128;
+const legacyCompatSourceCache = /* @__PURE__ */ new Map();
+const legacyCompatTransformCache = /* @__PURE__ */ new Map();
+function setLimitedCacheValue(cache, key, value) {
+	if (cache.size >= LEGACY_COMPAT_CACHE_LIMIT) {
+		const firstKey = cache.keys().next().value;
+		if (firstKey !== void 0) cache.delete(firstKey);
+	}
+	cache.set(key, value);
+}
+function createStableJson(value) {
+	if (value === void 0) return "undefined";
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => createStableJson(item)).join(",")}]`;
+	return `{${Object.keys(value).sort().map((key) => {
+		const record = value;
+		return `${JSON.stringify(key)}:${createStableJson(record[key])}`;
+	}).join(",")}}`;
+}
+function createLegacyCompatTransformCacheKey(source, options) {
+	return `${createStableJson(options)}\0${source}`;
+}
 function removeTailwindApplyRules(rawSource) {
 	try {
 		const root = postcss.default.parse(rawSource);
@@ -1195,7 +1475,11 @@ function removeTailwindApplyRules(rawSource) {
 	}
 }
 function resolveLegacyCompatCssSource(rawSource) {
-	return removeUnsupportedMiniProgramAtRules(removeTailwindApplyRules(removeTailwindSourceDirectives(stripTailwindBanners(rawSource))));
+	const cached = legacyCompatSourceCache.get(rawSource);
+	if (cached !== void 0) return cached;
+	const resolved = removeUnsupportedMiniProgramAtRules(removeTailwindApplyRules(removeTailwindSourceDirectives(stripTailwindBanners(rawSource))));
+	setLimitedCacheValue(legacyCompatSourceCache, rawSource, resolved);
+	return resolved;
 }
 function hasContainerConfigToken(rawSource) {
 	return rawSource.includes("@config") && /\bcontainer\b/.test(rawSource);
@@ -1228,10 +1512,16 @@ async function appendLegacyCompatCss(css, rawSource, generatorTarget, styleHandl
 	const compatSource = removeGeneratedSelectorCompatCss(resolveLegacyCompatCssSource(rawSource), css);
 	if (compatSource.trim().length === 0) return css;
 	if (generatorTarget !== "weapp") return createCssAppend(css, compatSource);
-	const { css: compatCss } = await styleHandler(compatSource, {
+	const styleOptions = {
 		...cssHandlerOptions,
 		...generatorStyleOptions
-	});
+	};
+	const compatCssCacheKey = createLegacyCompatTransformCacheKey(compatSource, styleOptions);
+	let compatCss = legacyCompatTransformCache.get(compatCssCacheKey);
+	if (compatCss === void 0) {
+		compatCss = (await styleHandler(compatSource, styleOptions)).css;
+		setLimitedCacheValue(legacyCompatTransformCache, compatCssCacheKey, compatCss);
+	}
 	const cleanedCompatCss = collectDedupedPostTransformCompatCss(removeDuplicatedViteMarkers(removeUnsupportedMiniProgramAtRules(compatCss), css), css);
 	if (cleanedCompatCss.trim().length === 0) return css;
 	return createCssAppend(css, cleanedCompatCss);
@@ -1240,10 +1530,16 @@ async function appendLegacyContainerCompatCss(css, rawSource, file, runtime, con
 	const compatSource = resolveLegacyCompatCssSource(rawSource);
 	const shouldAppendContainer = runtime.has("container") || hasConfiguredContainerCompat(rawSource, file, cssHandlerOptions) || configuredContainerCompat || collectGeneratedSelectors(compatSource).has(".container");
 	if (generatorTarget !== "weapp" || !shouldAppendContainer || collectGeneratedSelectors(css).has(".container")) return css;
-	const { css: compatCss } = await styleHandler(LEGACY_CONTAINER_COMPAT_CSS, {
+	const styleOptions = {
 		...cssHandlerOptions,
 		...generatorStyleOptions
-	});
+	};
+	const compatCssCacheKey = createLegacyCompatTransformCacheKey(LEGACY_CONTAINER_COMPAT_CSS, styleOptions);
+	let compatCss = legacyCompatTransformCache.get(compatCssCacheKey);
+	if (compatCss === void 0) {
+		compatCss = (await styleHandler(LEGACY_CONTAINER_COMPAT_CSS, styleOptions)).css;
+		setLimitedCacheValue(legacyCompatTransformCache, compatCssCacheKey, compatCss);
+	}
 	const cleanedCompatCss = collectDedupedPostTransformCompatCss(removeUnsupportedMiniProgramAtRules(compatCss), css);
 	if (cleanedCompatCss.trim().length === 0) return css;
 	return createCssAppend(css, cleanedCompatCss);
@@ -1296,15 +1592,25 @@ function inheritLegacyUnitConvertedDeclarations(css, legacyCss) {
 //#region src/bundlers/shared/generator-css.ts
 const SUPPORTED_GENERATOR_MAJOR_VERSIONS = new Set([3, 4]);
 const REMOTE_IMPORT_RE = /^(?:https?:)?\/\//i;
-function finalizeMiniProgramGeneratorCss(css, target) {
+function finalizeMiniProgramGeneratorCss(css, target, majorVersion, cssPreflight) {
 	if (target !== "weapp") return css;
-	return finalizeMiniProgramCss(css);
+	return finalizeMiniProgramCss(css, {
+		cssPreflight: majorVersion === 4 ? cssPreflight : void 0,
+		preservePseudoContentInit: majorVersion === 3
+	});
+}
+function mergeScopedRuntimeWithCurrentRuntime(scopedRuntime, runtime, options) {
+	if (runtime.size === 0 || !options.cssHandlerOptions.isMainChunk || options.isolateCssSource) return scopedRuntime;
+	return new Set([...scopedRuntime, ...runtime]);
+}
+function shouldIsolateMatchedCssSource(source, sourceEntries) {
+	return Boolean(source.__weappTailwindcssMeta?.matchedCssSourceFile && sourceEntries !== void 0);
 }
 function resolveGeneratorStyleOptions(opts, cssHandlerOptions, generatorStyleOptions) {
-	const tailwindV3StyleOptions = cssHandlerOptions.majorVersion === 3 ? {
+	const preflightStyleOptions = {
 		cssPreflight: opts.cssPreflight,
 		cssPreflightRange: opts.cssPreflightRange
-	} : {};
+	};
 	const resolvedUniAppXOptions = require_tailwindcss.resolveUniAppXOptions(opts.uniAppX);
 	return {
 		cssChildCombinatorReplaceValue: opts.cssChildCombinatorReplaceValue,
@@ -1322,7 +1628,7 @@ function resolveGeneratorStyleOptions(opts, cssHandlerOptions, generatorStyleOpt
 		uniAppXCssTarget: opts.uniAppXCssTarget,
 		uniAppXUnsupported: opts.uniAppXUnsupported,
 		...cssHandlerOptions,
-		...tailwindV3StyleOptions,
+		...preflightStyleOptions,
 		...generatorStyleOptions
 	};
 }
@@ -1382,7 +1688,7 @@ function prefixLocalCssImportsWithWebpackIgnore(css) {
 	}
 }
 async function generateCssByGenerator(options) {
-	const { opts, runtimeState, runtime, rawSource, file, cssHandlerOptions, cssUserHandlerOptions, styleHandler, debug } = options;
+	const { opts, runtimeState, runtime, rawSource, file, cssHandlerOptions, cssUserHandlerOptions, getSourceCandidatesForEntries, styleHandler, debug } = options;
 	const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator);
 	const majorVersion = runtimeState.twPatcher.majorVersion;
 	const effectiveRawSource = normalizeTailwindSourceDirectives(rawSource, { importFallback: generatorOptions.importFallback });
@@ -1401,13 +1707,25 @@ async function generateCssByGenerator(options) {
 	if (!SUPPORTED_GENERATOR_MAJOR_VERSIONS.has(majorVersion ?? 0) || !shouldGenerateCurrentCss || majorVersion === 3 && !hasSourceDirectives && !hasGeneratedCss && !hasGeneratedMarkers) return;
 	try {
 		await runtimeState.readyPromise;
-		const sources = await resolveGeneratorSources(majorVersion, runtimeState, effectiveRawSource, file, cssHandlerOptions, generatorOptions);
+		const sources = await resolveGeneratorSources(majorVersion, runtimeState, effectiveRawSource, file, cssHandlerOptions, generatorOptions, {
+			getSourceCandidatesForEntries,
+			runtime
+		});
 		const generatorStyleOptions = resolveGeneratorStyleOptions(opts, cssHandlerOptions, generatorOptions.styleOptions);
 		const configuredContainerCompat = hasConfiguredContainerCompatSources(sources);
 		const generatedResults = await Promise.all(sources.map(async (source) => {
-			return require_generator.createWeappTailwindcssGenerator(source).generate({
-				candidates: runtime,
-				scanSources: majorVersion === 4,
+			const generator = require_generator.createWeappTailwindcssGenerator(source);
+			const sourceEntries = getSourceCandidatesForEntries && majorVersion === 4 ? await resolveGeneratorSourceEntries(source, runtimeState) : void 0;
+			const scopedRuntime = sourceEntries ? getSourceCandidatesForEntries?.(sourceEntries) : void 0;
+			const isolateCssSource = shouldIsolateMatchedCssSource(source, sourceEntries);
+			const sourceRuntime = scopedRuntime && (scopedRuntime.size > 0 || isolateCssSource) ? mergeScopedRuntimeWithCurrentRuntime(scopedRuntime, runtime, {
+				cssHandlerOptions,
+				isolateCssSource
+			}) : runtime;
+			return generator.generate({
+				candidates: sourceRuntime,
+				incrementalCache: majorVersion === 3 || majorVersion === 4,
+				scanSources: majorVersion === 4 && sourceRuntime.size === 0 && !isolateCssSource,
 				styleOptions: generatorStyleOptions,
 				tailwindcssV3Compatibility: generatorOptions.tailwindcssV3Compatibility,
 				target: generatorOptions.target
@@ -1415,15 +1733,29 @@ async function generateCssByGenerator(options) {
 		}));
 		const firstGenerated = generatedResults[0];
 		if (!firstGenerated) return;
+		const incrementalCssResults = generatedResults.map((item) => item.incrementalCss).filter((css) => typeof css === "string");
+		const incrementalRawCssResults = generatedResults.map((item) => item.incrementalRawCss).filter((css) => typeof css === "string");
 		const generated = generatedResults.length === 1 ? firstGenerated : {
 			...firstGenerated,
 			css: generatedResults.map((item) => item.css).join("\n"),
 			rawCss: generatedResults.map((item) => item.rawCss).join("\n"),
+			incrementalCss: incrementalCssResults.length === generatedResults.length ? incrementalCssResults.filter(Boolean).join("\n") : void 0,
+			incrementalRawCss: incrementalRawCssResults.length === generatedResults.length ? incrementalRawCssResults.filter(Boolean).join("\n") : void 0,
 			classSet: new Set(generatedResults.flatMap((item) => [...item.classSet])),
 			dependencies: [...new Set(generatedResults.flatMap((item) => item.dependencies))],
 			sources: generatedResults.flatMap((item) => item.sources)
 		};
 		debug("tailwind generator result: %s rawBytes=%d cssBytes=%d candidates=%d", file, generated.rawCss.length, generated.css.length, generated.classSet.size);
+		if (typeof options.previousCss === "string" && typeof generated.incrementalCss === "string") {
+			const incrementalCss = stripTailwindBanner(generated.incrementalCss);
+			return {
+				css: incrementalCss.trim().length > 0 ? createCssAppend(options.previousCss, finalizeMiniProgramGeneratorCss(incrementalCss, generated.target, majorVersion, opts.cssPreflight)) : options.previousCss,
+				target: generated.target,
+				source: "generator",
+				dependencies: generated.dependencies,
+				incremental: true
+			};
+		}
 		const extraCss = splitTailwindV4GeneratedCss(effectiveRawSource, generated.rawCss);
 		if (typeof extraCss === "string") {
 			let css = stripTailwindBanner(generated.css);
@@ -1433,7 +1765,7 @@ async function generateCssByGenerator(options) {
 				if (cleanedExtraCss.trim().length > 0) {
 					const extraSource = generated.target === "weapp" ? removeUnsupportedMiniProgramAtRules(cleanedExtraCss) : cleanedExtraCss;
 					if (extraSource.trim().length === 0) return {
-						css: finalizeMiniProgramGeneratorCss(css, generated.target),
+						css: finalizeMiniProgramGeneratorCss(css, generated.target, majorVersion, opts.cssPreflight),
 						target: generated.target,
 						source: "generator",
 						dependencies: generated.dependencies
@@ -1452,7 +1784,7 @@ async function generateCssByGenerator(options) {
 				css = await appendLegacyContainerCompatCss(css, effectiveRawSource, file, runtime, configuredContainerCompat, generated.target, styleHandler, cssHandlerOptions, generatorStyleOptions);
 			}
 			return {
-				css: finalizeMiniProgramGeneratorCss(css, generated.target),
+				css: finalizeMiniProgramGeneratorCss(css, generated.target, majorVersion, opts.cssPreflight),
 				target: generated.target,
 				source: "generator",
 				dependencies: generated.dependencies
@@ -1461,10 +1793,16 @@ async function generateCssByGenerator(options) {
 		debug("tailwind direct css generation prefix mismatch, append transformed bundle css %s", file);
 		let css = stripTailwindBanner(generated.css);
 		if (generated.target === "weapp") css = inheritLegacyUnitConvertedDeclarations(css, effectiveRawSource);
+		if (sources.some((source) => source.__weappTailwindcssMeta?.matchedCssSourceFile)) return {
+			css: finalizeMiniProgramGeneratorCss(css, generated.target, majorVersion, opts.cssPreflight),
+			target: generated.target,
+			source: "generator",
+			dependencies: generated.dependencies
+		};
 		css = await appendLegacyCompatCss(css, effectiveRawSource, generated.target, styleHandler, cssHandlerOptions, generatorStyleOptions);
 		css = await appendLegacyContainerCompatCss(css, effectiveRawSource, file, runtime, configuredContainerCompat, generated.target, styleHandler, cssHandlerOptions, generatorStyleOptions);
 		return {
-			css: finalizeMiniProgramGeneratorCss(css, generated.target),
+			css: finalizeMiniProgramGeneratorCss(css, generated.target, majorVersion, opts.cssPreflight),
 			target: generated.target,
 			source: "generator",
 			dependencies: generated.dependencies
@@ -1478,7 +1816,7 @@ async function validateCandidatesByGenerator(options) {
 	const { candidates, cssHandlerOptions, debug, file, opts, rawSource, runtimeState } = options;
 	const majorVersion = runtimeState.twPatcher.majorVersion;
 	if (!SUPPORTED_GENERATOR_MAJOR_VERSIONS.has(majorVersion ?? 0) || candidates.size === 0) return /* @__PURE__ */ new Set();
-	const sources = await resolveGeneratorSources(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator));
+	const sources = await resolveGeneratorSources(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator), { runtime: candidates });
 	const classSets = await Promise.all(sources.map(async (source) => {
 		const generator = require_generator.createWeappTailwindcssGenerator(source);
 		if (typeof generator.validateCandidates === "function") return generator.validateCandidates(candidates);
@@ -1496,19 +1834,82 @@ async function validateCandidatesByGenerator(options) {
 function shouldEmitHmrTiming() {
 	return node_process.default.env["WEAPP_TW_WATCH_REGRESSION"] === "1" || node_process.default.env["WEAPP_TW_HMR_TIMING"] === "1";
 }
+function shouldEmitHumanReadableTiming() {
+	return node_process.default.env["WEAPP_TW_HMR_TIMING"] === "1" && node_process.default.env["WEAPP_TW_HMR_TIMING_LOG"] !== "0";
+}
 function emitHmrTiming(bundler, phase, durationMs, details = {}) {
 	if (!shouldEmitHmrTiming()) return;
+	const serializableDetails = { ...details };
+	delete serializableDetails.emit;
 	const payload = {
 		bundler,
 		phase,
 		durationMs: Math.max(0, Math.round(durationMs)),
-		...details
+		...serializableDetails,
+		...typeof details.wallMs === "number" ? { wallMs: Math.max(0, Math.round(details.wallMs)) } : {}
 	};
 	node_process.default.stdout.write(`[weapp-tailwindcss:hmr] ${JSON.stringify(payload)}\n`);
+	if (shouldEmitHumanReadableTiming()) {
+		const fileSuffix = details.file ? ` file=${details.file}` : "";
+		if (details.metric === "total") {
+			const hooks = details.hooks ? Object.entries(details.hooks).map(([hook, summary]) => `${hook}=${Math.max(0, Math.round(summary.durationMs))}ms/${summary.count}`).join(", ") : "";
+			const hookSuffix = hooks ? ` (${hooks})` : "";
+			const wallSuffix = typeof payload.wallMs === "number" ? ` wall=${payload.wallMs}ms` : "";
+			node_process.default.stdout.write(`[weapp-tailwindcss] ${bundler}:weapp-tailwindcss 总耗时 ${payload.durationMs}ms${wallSuffix}${hookSuffix}\n`);
+			return;
+		}
+		node_process.default.stdout.write(`[weapp-tailwindcss] ${bundler}:${phase} 耗时 ${payload.durationMs}ms${fileSuffix}\n`);
+	}
+}
+function createHmrTimingRecorder(bundler) {
+	const session = {
+		hooks: {},
+		totalMs: 0
+	};
+	const record = (phase, durationMs, details = {}) => {
+		const roundedDuration = Math.max(0, Math.round(durationMs));
+		if (session.startedAt === void 0) session.startedAt = performance.now() - Math.max(0, durationMs);
+		session.totalMs += Math.max(0, durationMs);
+		const current = session.hooks[phase] ?? {
+			count: 0,
+			durationMs: 0,
+			maxMs: 0
+		};
+		current.count += 1;
+		current.durationMs += roundedDuration;
+		current.maxMs = Math.max(current.maxMs, roundedDuration);
+		session.hooks[phase] = current;
+		if (details.emit !== false) emitHmrTiming(bundler, phase, durationMs, details);
+	};
+	const measure = async (phase, task, details = {}) => {
+		const startedAt = performance.now();
+		try {
+			return await task();
+		} finally {
+			record(phase, performance.now() - startedAt, details);
+		}
+	};
+	const emitTotal = (phase = "total") => {
+		if (session.totalMs <= 0) return;
+		const wallMs = session.startedAt === void 0 ? session.totalMs : performance.now() - session.startedAt;
+		emitHmrTiming(bundler, phase, session.totalMs, {
+			hooks: session.hooks,
+			metric: "total",
+			wallMs
+		});
+		session.hooks = {};
+		delete session.startedAt;
+		session.totalMs = 0;
+	};
+	return {
+		emitTotal,
+		measure,
+		record
+	};
 }
 //#endregion
 //#region src/bundlers/vite/incremental-runtime-class-set.ts
-const debug = require_runtime_patch.createDebug("[vite:runtime-set] ");
+const debug = require_v3_engine.createDebug("[vite:runtime-set] ");
 const EXTENSION_DOT_PREFIX_RE = /^\./;
 function createExtractOptions(context, source) {
 	return {
@@ -1581,7 +1982,7 @@ function createBundleRuntimeClassSetManager(options = {}) {
 		designSystemPromise = void 0;
 	}
 	async function resolveValidationContextCached(patcher) {
-		if (!validationContext) validationContext = await require_generator.resolveTailwindV4SourceFromPatcher(patcher);
+		if (!validationContext) validationContext = await require_v3_engine.resolveTailwindV4SourceFromPatcher(patcher);
 		return validationContext;
 	}
 	async function loadDesignSystem(context) {
@@ -1628,10 +2029,11 @@ function createBundleRuntimeClassSetManager(options = {}) {
 		return candidates;
 	}
 	async function sync(patcher, snapshot, options = {}) {
-		const nextSignature = require_cache.getRuntimeClassSetSignature(patcher) ?? "runtime:missing";
+		const nextSignature = require_v3_engine.getRuntimeClassSetSignature(patcher) ?? "runtime:missing";
 		const runtimeEntries = createRuntimeEntries(snapshot);
 		const runtimeEntriesByFile = new Map(runtimeEntries.map((entry) => [entry.file, entry]));
 		const currentRuntimeFiles = new Set(runtimeEntriesByFile.keys());
+		const hadTrackedRuntimeFiles = candidatesByFile.size > 0;
 		const fullRebuild = runtimeSignature !== nextSignature || candidatesByFile.size === 0;
 		if (runtimeSignature !== nextSignature) {
 			debug("runtime signature changed, reset incremental runtime set: %s", nextSignature);
@@ -1639,14 +2041,15 @@ function createBundleRuntimeClassSetManager(options = {}) {
 		}
 		runtimeSignature = nextSignature;
 		const nextBaseClassSet = options.baseClassSet;
+		const canUseBaseWithoutInitialFullScan = Boolean(fullRebuild && !hadTrackedRuntimeFiles && options.skipInitialFullScanWithBase === true && nextBaseClassSet && nextBaseClassSet.size > 0);
 		for (const [file, previousCandidates] of candidatesByFile) {
 			if (currentRuntimeFiles.has(file)) continue;
 			removeCandidateSet(candidateCountByClass, previousCandidates);
 			candidatesByFile.delete(file);
 		}
-		const changedRuntimeFiles = fullRebuild ? [...runtimeEntriesByFile.keys()] : [...collectChangedRuntimeFiles(snapshot)];
+		const changedRuntimeFiles = canUseBaseWithoutInitialFullScan ? [...collectChangedRuntimeFiles(snapshot)] : fullRebuild ? [...runtimeEntriesByFile.keys()] : [...collectChangedRuntimeFiles(snapshot)];
 		if (changedRuntimeFiles.length === 0) {
-			if (nextBaseClassSet) baseClassSet = createNonSourceBaseClassSet(nextBaseClassSet, candidateCountByClass);
+			if (nextBaseClassSet) baseClassSet = canUseBaseWithoutInitialFullScan ? new Set(nextBaseClassSet) : createNonSourceBaseClassSet(nextBaseClassSet, candidateCountByClass);
 			return createRuntimeClassSet(baseClassSet, candidateCountByClass);
 		}
 		const rawCandidatesByFile = /* @__PURE__ */ new Map();
@@ -1677,7 +2080,7 @@ function createBundleRuntimeClassSetManager(options = {}) {
 			addCandidateSet(candidateCountByClass, nextCandidates);
 			candidatesByFile.set(file, nextCandidates);
 		}
-		if (nextBaseClassSet) baseClassSet = createNonSourceBaseClassSet(nextBaseClassSet, candidateCountByClass);
+		if (nextBaseClassSet) baseClassSet = canUseBaseWithoutInitialFullScan ? new Set(nextBaseClassSet) : createNonSourceBaseClassSet(nextBaseClassSet, candidateCountByClass);
 		const runtimeSet = createRuntimeClassSet(baseClassSet, candidateCountByClass);
 		debug("incremental runtime set synced, changedFiles=%d rawCandidates=%d validateMisses=%d runtimeSize=%d trackedFiles=%d", changedRuntimeFiles.length, rawCandidateCount, unknownCandidates.size, runtimeSet.size, candidatesByFile.size);
 		return new Set(runtimeSet);
@@ -1694,6 +2097,12 @@ Object.defineProperty(exports, "createBundleRuntimeClassSetManager", {
 		return createBundleRuntimeClassSetManager;
 	}
 });
+Object.defineProperty(exports, "createHmrTimingRecorder", {
+	enumerable: true,
+	get: function() {
+		return createHmrTimingRecorder;
+	}
+});
 Object.defineProperty(exports, "emitHmrTiming", {
 	enumerable: true,
 	get: function() {