weapp-tailwindcss 5.0.0-next.3 → 5.0.0-next.30

package/dist/incremental-runtime-class-set-BxvZONkv.js

@@ -0,0 +1,2038 @@
+const require_chunk = require("./chunk-C5U5_Hdc.js");
+const require_v3_engine = require("./v3-engine-CHItlVq5.js");
+const require_generator = require("./generator-CrU-Ghc1.js");
+const require_precheck = require("./precheck-D7gJSmJz.js");
+let node_fs = require("node:fs");
+let postcss = require("postcss");
+postcss = require_chunk.__toESM(postcss);
+let node_path = require("node:path");
+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 _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
+//#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)-/;
+const GENERATOR_PLACEHOLDER_MARKER_RE = /\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\//i;
+const GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE = /\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\/\s*/gi;
+const TAILWIND_BANNER_PREFIX_RE = /^\/\*!\s*tailwindcss v[^*]*\*\/\s*/i;
+const TAILWIND_BANNER_RE = /\/\*!\s*tailwindcss v[^*]*\*\//i;
+const TAILWIND_BANNER_GLOBAL_RE = /\/\*!\s*tailwindcss v[^*]*\*\/\s*/gi;
+const VITE_MARKER_RE = /\/\*\$vite\$:[^*]*\*\//g;
+function createCssAppend(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	return `${base}\n${extra}`;
+}
+function splitTailwindV4GeneratedCssBySourceOrder(rawSource, rawTailwindCss) {
+	const trimmedRaw = rawSource.trim();
+	const trimmedTailwind = rawTailwindCss.trim();
+	if (trimmedRaw === trimmedTailwind) return {
+		before: "",
+		after: ""
+	};
+	if (trimmedTailwind.startsWith(trimmedRaw)) return {
+		before: "",
+		after: ""
+	};
+	const start = rawSource.indexOf(rawTailwindCss);
+	if (start === -1) return;
+	return {
+		before: rawSource.slice(0, start),
+		after: rawSource.slice(start + rawTailwindCss.length)
+	};
+}
+function splitGeneratorPlaceholderCssBySourceOrder(rawSource, rawTailwindCss) {
+	const match = GENERATOR_PLACEHOLDER_MARKER_RE.exec(rawSource);
+	if (!match || match.index === void 0) return;
+	let afterStart = match.index + match[0].length;
+	while (/\s/.test(rawSource[afterStart] ?? "")) afterStart++;
+	if (rawTailwindCss && rawSource.slice(afterStart).startsWith(rawTailwindCss)) {
+		afterStart += rawTailwindCss.length;
+		while (/\s/.test(rawSource[afterStart] ?? "")) afterStart++;
+	}
+	return {
+		before: rawSource.slice(0, match.index),
+		after: rawSource.slice(afterStart)
+	};
+}
+function splitTailwindGeneratedCssByBanner(rawSource, start) {
+	const match = start === void 0 ? TAILWIND_BANNER_RE.exec(rawSource) : { index: start };
+	if (!match || match.index === void 0) return;
+	return {
+		before: rawSource.slice(0, match.index),
+		after: [...rawSource.slice(match.index).matchAll(VITE_MARKER_RE)].map((item) => item[0]).join("\n")
+	};
+}
+function stripTailwindBanner(css) {
+	return css.replace(TAILWIND_BANNER_PREFIX_RE, "");
+}
+function stripTailwindBanners(css) {
+	return css.replace(TAILWIND_BANNER_GLOBAL_RE, "");
+}
+function stripGeneratorPlaceholderMarkers(css) {
+	return css.replace(GENERATOR_PLACEHOLDER_MARKER_GLOBAL_RE, "");
+}
+function hasTailwindGeneratedCss(rawSource) {
+	return TAILWIND_V4_BANNER_RE.test(rawSource);
+}
+function hasTailwindGeneratedCssMarkers(rawSource) {
+	return TAILWIND_GENERATED_CSS_MARKER_RE.test(rawSource) || GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource);
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/directives.ts
+const TAILWIND_REMOVABLE_SOURCE_DIRECTIVE_NAMES = new Set([
+	"config",
+	"custom-variant",
+	"layer",
+	"plugin",
+	"reference",
+	"source",
+	"tailwind",
+	"theme",
+	"utility",
+	"variant"
+]);
+const TAILWIND_ROOT_DIRECTIVE_NAMES = new Set([
+	"config",
+	"custom-variant",
+	"plugin",
+	"source",
+	"tailwind",
+	"theme",
+	"utility",
+	"variant"
+]);
+const TAILWIND_ROOT_DIRECTIVE_RE = /@(?:import\s+(?:url\(\s*)?["']?tailwindcss4?(?:\/[^"')\s]*)?|(?:use|forward)\s+(?:url\(\s*)?["']?tailwindcss4?(?:\/[^"')\s]*)?|tailwind|config|custom-variant|plugin|source|theme|utility|variant)\b/;
+const TAILWIND_EXTRACTABLE_DIRECTIVE_RE = /^\s*@(?:import|use|forward|tailwind|config|source|reference|plugin)\b[\s\S]*?(?:;|$)/;
+const TAILWIND_EXTRACTABLE_LAYER_STATEMENT_RE = /^\s*@layer\s[^;{]+;\s*$/;
+const TAILWIND_EXTRACTABLE_BLOCK_START_RE = /^\s*@(?:layer|theme|utility|variant|custom-variant)\b[\s\S]*\{/;
+function parseImportRequest(params) {
+	return /^(?:url\(\s*)?(["']?)([^"')\s]+)\1\s*\)?/.exec(params.trim())?.[2];
+}
+function parseConfigRequest(params) {
+	return /^(["'])(.+)\1\s*;?$/.exec(params.trim())?.[2];
+}
+function isPackageJsonImportRequest(request) {
+	return typeof request === "string" && request.startsWith("#");
+}
+function isWeappTailwindcssImportRequest(request) {
+	return request === "weapp-tailwindcss" || request?.startsWith("weapp-tailwindcss/");
+}
+function normalizeTailwindImportRequest(request, options = {}) {
+	if (options.importFallback && isWeappTailwindcssImportRequest(request)) return request.replace(/^weapp-tailwindcss/, "tailwindcss");
+	return request;
+}
+function replaceImportRequest(params, request, replacement) {
+	const index = params.indexOf(request);
+	if (index === -1) return params;
+	return `${params.slice(0, index)}${replacement}${params.slice(index + request.length)}`;
+}
+function normalizeTailwindImportAtRules(root, options = {}) {
+	if (!options.importFallback) return false;
+	let changed = false;
+	const seenCanonicalImports = /* @__PURE__ */ new Set();
+	root.walkAtRules("import", (node) => {
+		const request = parseImportRequest(node.params);
+		const normalizedRequest = normalizeTailwindImportRequest(request, options);
+		if (!normalizedRequest || !isTailwindImportRequest(normalizedRequest)) return;
+		const normalizedParams = request && normalizedRequest !== request ? replaceImportRequest(node.params, request, normalizedRequest) : node.params;
+		const normalizedKey = normalizedParams.trim();
+		if (seenCanonicalImports.has(normalizedKey)) {
+			node.remove();
+			changed = true;
+			return;
+		}
+		seenCanonicalImports.add(normalizedKey);
+		if (normalizedParams !== node.params) {
+			node.params = normalizedParams;
+			changed = true;
+		}
+	});
+	return changed;
+}
+function normalizeTailwindDirectiveLine(line, options = {}) {
+	const trimmed = line.trimStart();
+	if (/^@(?:use|forward)\b/.test(trimmed)) {
+		const request = parseImportRequest(trimmed.replace(/^@(?:use|forward)\b/, ""));
+		if (isTailwindImportRequest(request) || options.importFallback && isWeappTailwindcssImportRequest(request)) {
+			const normalizedRequest = normalizeTailwindImportRequest(request, options);
+			return replaceImportRequest(line.replace(/^(\s*)@(?:use|forward)\b/, "$1@import"), request, normalizedRequest);
+		}
+		return line;
+	}
+	if (!options.importFallback || !trimmed.startsWith("@import")) return line;
+	const request = parseImportRequest(trimmed.replace(/^@import\b/, ""));
+	if (!request || !isWeappTailwindcssImportRequest(request)) return line;
+	return replaceImportRequest(line, request, request.replace(/^weapp-tailwindcss/, "tailwindcss"));
+}
+function extractTailwindDirectiveLines(rawSource, options = {}) {
+	const directives = [];
+	const seenImports = /* @__PURE__ */ new Set();
+	for (const line of stripGeneratorPlaceholderMarkers(rawSource).split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("//")) continue;
+		const directive = TAILWIND_EXTRACTABLE_DIRECTIVE_RE.exec(line)?.[0] ?? TAILWIND_EXTRACTABLE_LAYER_STATEMENT_RE.exec(line)?.[0];
+		if (!directive) continue;
+		const normalized = normalizeTailwindDirectiveLine(directive.trimEnd(), options);
+		const normalizedTrimmed = normalized.trim();
+		if (options.removeConfig && normalizedTrimmed.startsWith("@config")) continue;
+		const request = /^@(?:import|use|forward)\b/.test(normalizedTrimmed) ? parseImportRequest(normalizedTrimmed.replace(/^@(?:import|use|forward)\b/, "")) : void 0;
+		if (request && !isTailwindImportRequest(request) && !isPackageJsonImportRequest(request)) continue;
+		if (/^@(?:import|use|forward)\b/.test(normalizedTrimmed) && !request) continue;
+		if (request && isTailwindImportRequest(request)) {
+			const key = normalizedTrimmed;
+			if (seenImports.has(key)) continue;
+			seenImports.add(key);
+		}
+		directives.push(normalized);
+	}
+	return directives;
+}
+function stripPreprocessorLineComment(line) {
+	let quote;
+	let escaped = false;
+	for (let index = 0; index < line.length; index++) {
+		const char = line[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "/" && line[index + 1] === "/" && (index === 0 || /\s/.test(line[index - 1]))) return line.slice(0, index).trimEnd();
+	}
+	return line;
+}
+function countBlockBraceDelta(line) {
+	let quote;
+	let escaped = false;
+	let delta = 0;
+	for (let index = 0; index < line.length; index++) {
+		const char = line[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "{") delta++;
+		else if (char === "}") delta--;
+	}
+	return delta;
+}
+function extractTailwindFallbackBlocks(rawSource) {
+	const blocks = [];
+	let current;
+	let depth = 0;
+	for (const rawLine of stripGeneratorPlaceholderMarkers(rawSource).split(/\r?\n/)) {
+		const line = stripPreprocessorLineComment(rawLine);
+		if (!line.trim()) continue;
+		if (!current) {
+			if (!TAILWIND_EXTRACTABLE_BLOCK_START_RE.test(line)) continue;
+			current = [line];
+			depth = countBlockBraceDelta(line);
+			if (depth <= 0) {
+				blocks.push(current.join("\n"));
+				current = void 0;
+				depth = 0;
+			}
+			continue;
+		}
+		current.push(line);
+		depth += countBlockBraceDelta(line);
+		if (depth <= 0) {
+			blocks.push(current.join("\n"));
+			current = void 0;
+			depth = 0;
+		}
+	}
+	return blocks;
+}
+function extractTailwindSourceForPostcssFallback(rawSource, options = {}) {
+	const directives = [...extractTailwindDirectiveLines(rawSource, options), ...extractTailwindFallbackBlocks(rawSource)];
+	return directives.length > 0 ? directives.join("\n") : void 0;
+}
+function extractConfigRequestFromSource(rawSource) {
+	for (const line of rawSource.split(/\r?\n/)) {
+		const match = /^\s*@config\b([\s\S]*?)(?:;|$)/.exec(line);
+		const request = match ? parseConfigRequest(match[1] ?? "") : void 0;
+		if (request) return request;
+	}
+}
+function hasPreprocessorOnlySyntax(rawSource) {
+	return /(?:^|\n)\s*(?:\/\/|\$[\w-]+\s*:|@[\w-]+\s*:|@(?:mixin|include|function|use|forward)\b)/.test(rawSource);
+}
+function normalizeTailwindSourceForGenerator(rawSource, options = {}) {
+	return hasPreprocessorOnlySyntax(rawSource) ? extractTailwindSourceForPostcssFallback(rawSource, options) ?? rawSource : rawSource;
+}
+function normalizeTailwindSourceDirectives(rawSource, options = {}) {
+	if (!options.importFallback) return rawSource;
+	try {
+		const root = postcss.default.parse(rawSource);
+		return normalizeTailwindImportAtRules(root, options) ? root.toString() : rawSource;
+	} catch {
+		return extractTailwindSourceForPostcssFallback(rawSource, options) ?? rawSource;
+	}
+}
+function isTailwindImportRequest(request) {
+	return request === "tailwindcss" || request === "tailwindcss4" || request?.startsWith("tailwindcss/") || request?.startsWith("tailwindcss4/");
+}
+function isTailwindImportAtRule(node, options = {}) {
+	if (node.name === "tailwind") return true;
+	if (node.name !== "import" && node.name !== "use" && node.name !== "forward") return false;
+	return isTailwindImportRequest(normalizeTailwindImportRequest(parseImportRequest(node.params), options));
+}
+function isTailwindSourceDirective(node, options = {}) {
+	if (node.type !== "atrule") return false;
+	const atRule = node;
+	if (isTailwindImportAtRule(atRule, options)) return true;
+	if (atRule.name === "import" && isPackageJsonImportRequest(parseImportRequest(atRule.params))) return true;
+	if (atRule.name === "layer") return !atRule.nodes || atRule.nodes.length === 0;
+	return TAILWIND_REMOVABLE_SOURCE_DIRECTIVE_NAMES.has(atRule.name);
+}
+function hasGeneratedCssArtifacts(rawSource) {
+	return hasTailwindGeneratedCssMarkers(rawSource) && !GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource);
+}
+function isTailwindGenerationDirective(node, options = {}) {
+	if (node.type !== "atrule") return false;
+	const atRule = node;
+	const request = atRule.name === "import" ? parseImportRequest(atRule.params) : atRule.name === "config" || atRule.name === "plugin" || atRule.name === "reference" ? parseConfigRequest(atRule.params) : void 0;
+	return isTailwindImportAtRule(atRule, options) || isPackageJsonImportRequest(request) || atRule.name === "apply" || !options.ignoreLayer && atRule.name === "layer" || atRule.name === "config" || atRule.name === "source";
+}
+function removeTailwindSourceDirectives(rawSource, options = {}) {
+	try {
+		const source = hasPreprocessorOnlySyntax(rawSource) ? extractTailwindSourceForPostcssFallback(rawSource, options) : stripGeneratorPlaceholderMarkers(rawSource);
+		if (!source) return "";
+		const root = postcss.default.parse(source);
+		let removed = false;
+		root.walk((node) => {
+			if (isTailwindSourceDirective(node, options)) {
+				node.remove();
+				removed = true;
+			}
+		});
+		return removed ? root.toString() : source;
+	} catch {
+		return stripGeneratorPlaceholderMarkers(rawSource);
+	}
+}
+function hasTailwindSourceDirectives(rawSource, options = {}) {
+	try {
+		if (GENERATOR_PLACEHOLDER_MARKER_RE.test(rawSource)) return true;
+		const root = postcss.default.parse(rawSource);
+		let found = false;
+		const ignoreLayer = hasGeneratedCssArtifacts(rawSource);
+		root.walk((node) => {
+			if (isTailwindGenerationDirective(node, {
+				...options,
+				ignoreLayer
+			})) {
+				found = true;
+				return false;
+			}
+		});
+		return found;
+	} catch {
+		return extractTailwindDirectiveLines(rawSource, options).length > 0;
+	}
+}
+function hasTailwindRootDirectives(rawSource, options = {}) {
+	if (!TAILWIND_ROOT_DIRECTIVE_RE.test(rawSource) && !(options.importFallback && rawSource.includes("weapp-tailwindcss"))) return false;
+	try {
+		const root = postcss.default.parse(rawSource);
+		let found = false;
+		root.walkAtRules((node) => {
+			const request = node.name === "import" ? parseImportRequest(node.params) : node.name === "config" || node.name === "plugin" ? parseConfigRequest(node.params) : void 0;
+			if (isTailwindImportAtRule(node, options) || isPackageJsonImportRequest(request) || TAILWIND_ROOT_DIRECTIVE_NAMES.has(node.name)) {
+				found = true;
+				return false;
+			}
+		});
+		return found;
+	} catch {
+		return extractTailwindDirectiveLines(rawSource, options).length > 0;
+	}
+}
+function hasTailwindApplyDirective(rawSource) {
+	if (!rawSource.includes("@apply")) return false;
+	try {
+		const root = postcss.default.parse(rawSource);
+		let found = false;
+		root.walkAtRules("apply", () => {
+			found = true;
+			return false;
+		});
+		return found;
+	} catch {
+		return false;
+	}
+}
+function resolveCssEntrySource(rawSource, base, options = {}) {
+	try {
+		const root = postcss.default.parse(rawSource);
+		const normalizedImports = normalizeTailwindImportAtRules(root, options);
+		let found = false;
+		let config;
+		let configRequest;
+		let removedConfig = false;
+		const removeConfig = options.removeConfig ?? true;
+		const ignoreLayer = hasGeneratedCssArtifacts(rawSource);
+		root.walk((node) => {
+			if (isTailwindGenerationDirective(node, {
+				...options,
+				ignoreLayer
+			})) found = true;
+			if (node.type === "atrule" && node.name === "config") {
+				const configPath = parseConfigRequest(node.params);
+				if (configPath && !config) {
+					configRequest = configPath;
+					config = isPackageJsonImportRequest(configPath) ? void 0 : node_path.default.isAbsolute(configPath) ? configPath : node_path.default.resolve(base, configPath);
+				}
+				if (removeConfig) {
+					node.remove();
+					removedConfig = true;
+				}
+			}
+		});
+		if (!found) return;
+		if (hasPreprocessorOnlySyntax(rawSource)) {
+			const css = extractTailwindSourceForPostcssFallback(rawSource, {
+				...options,
+				removeConfig
+			});
+			if (css) return {
+				css,
+				config,
+				configRequest,
+				base
+			};
+		}
+		return {
+			css: removedConfig || normalizedImports ? root.toString() : rawSource,
+			config,
+			configRequest,
+			base
+		};
+	} catch {
+		const css = extractTailwindSourceForPostcssFallback(rawSource, options);
+		const configRequest = extractConfigRequestFromSource(rawSource);
+		const config = configRequest && !isPackageJsonImportRequest(configRequest) ? node_path.default.isAbsolute(configRequest) ? configRequest : node_path.default.resolve(base, configRequest) : void 0;
+		return css ? {
+			css,
+			config,
+			configRequest,
+			base
+		} : void 0;
+	}
+}
+//#endregion
+//#region src/bundlers/shared/cache.ts
+async function processCachedTask({ cache, cacheKey, hashKey = cacheKey, rawSource, hash, readCache, applyResult, transform, onCacheHit }) {
+	let cacheHit = false;
+	const result = await cache.process({
+		key: cacheKey,
+		hashKey,
+		rawSource,
+		hash,
+		resolveCache: readCache,
+		async onCacheHit(value) {
+			cacheHit = true;
+			await applyResult(value);
+			onCacheHit?.();
+		},
+		transform
+	});
+	if (!cacheHit) await applyResult(result);
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/legacy-selectors.ts
+const CLASS_SELECTOR_RE = /(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i;
+const MINI_PROGRAM_THEME_SCOPE_SELECTORS = new Set([
+	":host",
+	"page",
+	".tw-root",
+	"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();
+}
+function isClassSelectorTerminator(char) {
+	return /[\s>+~#,.:()[\]]/.test(char);
+}
+function unescapeSimpleCssIdent(value) {
+	return value.replaceAll(/\\(.)/g, "$1");
+}
+function escapeCompatSelectorClasses(selector) {
+	let result = "";
+	let index = 0;
+	let changed = false;
+	while (index < selector.length) {
+		const char = selector[index];
+		if (char !== ".") {
+			result += char;
+			index += 1;
+			continue;
+		}
+		let end = index + 1;
+		let className = "";
+		while (end < selector.length) {
+			const current = selector[end];
+			if (current === void 0) break;
+			if (current === "\\" && end + 1 < selector.length) {
+				const escaped = selector[end + 1];
+				if (escaped === void 0) break;
+				className += current + escaped;
+				end += 2;
+				continue;
+			}
+			if (isClassSelectorTerminator(current)) break;
+			className += current;
+			end += 1;
+		}
+		if (className.includes("\\")) {
+			result += `.${require_precheck.replaceWxml(unescapeSimpleCssIdent(className))}`;
+			changed = true;
+		} else result += `.${className}`;
+		index = end;
+	}
+	return changed ? result : selector;
+}
+function normalizeCompatSelectors(selector) {
+	const normalized = normalizeCompatSelector(selector);
+	if (!normalized) return [];
+	const selectors = new Set([normalized]);
+	const escaped = normalizeCompatSelector(escapeCompatSelectorClasses(normalized));
+	if (escaped) selectors.add(escaped);
+	return [...selectors];
+}
+function normalizeCssSelector(selector) {
+	return selector.trim().replace(/\s+/g, "");
+}
+function getCompatSelectorKeys(selector) {
+	return normalizeCompatSelectors(selector).map(normalizeCssSelector);
+}
+function getRuleCompatSelectorKeys(rule) {
+	return (rule.selectors?.length ? rule.selectors : [rule.selector]).flatMap((selector) => getCompatSelectorKeys(selector));
+}
+function hasClassSelector(selector) {
+	return CLASS_SELECTOR_RE.test(selector);
+}
+function getNormalizedSelectorList(selector) {
+	return selector.split(",").map(normalizeCssSelector).filter(Boolean);
+}
+function isMiniProgramThemeScopeSelector(selector) {
+	const selectors = getNormalizedSelectorList(selector);
+	return selectors.length > 0 && selectors.every((item) => MINI_PROGRAM_THEME_SCOPE_SELECTORS.has(item));
+}
+function hasUtilityClassSelector(selector) {
+	return hasClassSelector(selector) && !isMiniProgramThemeScopeSelector(selector);
+}
+function isCustomPropertyOnlyRule(rule) {
+	let hasDeclaration = false;
+	let allCustomProperties = true;
+	rule.each((node) => {
+		if (node.type !== "decl") return;
+		hasDeclaration = true;
+		if (!node.prop.startsWith("--")) allCustomProperties = false;
+	});
+	return hasDeclaration && allCustomProperties;
+}
+function isPseudoContentInitRule(rule) {
+	let hasDeclaration = false;
+	let onlyContentVariable = true;
+	rule.each((node) => {
+		if (node.type !== "decl") return;
+		hasDeclaration = true;
+		if (node.prop !== "--tw-content") onlyContentVariable = false;
+	});
+	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) => {
+			if (isCustomPropertyOnlyRule(rule) && !isPseudoContentInitRule(rule) && !hasUtilityClassSelector(rule.selector)) return;
+			for (const selector of getRuleCompatSelectorKeys(rule)) selectors.add(selector);
+		});
+	} 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;
+	try {
+		const root = postcss.default.parse(css);
+		let removed = false;
+		root.walkRules((rule) => {
+			if (isPseudoContentInitRule(rule)) {
+				rule.remove();
+				removed = true;
+				return;
+			}
+			if (isCustomPropertyOnlyRule(rule) && !isPseudoContentInitRule(rule) && !hasUtilityClassSelector(rule.selector)) return;
+			if (getRuleCompatSelectorKeys(rule).some((selector) => generatedSelectors.has(selector))) {
+				rule.remove();
+				removed = true;
+			}
+		});
+		root.walkAtRules((atRule) => {
+			if (atRule.nodes && atRule.nodes.length === 0) atRule.remove();
+		});
+		return removed ? root.toString() : css;
+	} catch {
+		return css;
+	}
+}
+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") {
+				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);
+					});
+					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();
+					});
+					if (nextRule.nodes.length > 0) preservedNodes.push(nextRule);
+				}
+				return;
+			}
+			preservedNodes.push(node.clone());
+		});
+		if (preservedNodes.length === root.nodes.length) return css;
+		const nextRoot = postcss.default.root();
+		nextRoot.append(preservedNodes);
+		return nextRoot.toString();
+	} catch {
+		return css;
+	}
+}
+function removeDuplicatedViteMarkers(css, baseCss) {
+	if (!VITE_MARKER_RE.test(baseCss)) return css;
+	VITE_MARKER_RE.lastIndex = 0;
+	return css.replace(VITE_MARKER_RE, "");
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/config-directive.ts
+function quoteCssString(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+function toCssPath(value) {
+	return value.replaceAll("\\", "/");
+}
+function prependConfigDirective(css, config) {
+	if (!config || /@config\s+/.test(css)) return css;
+	return `@config "${quoteCssString(toCssPath(config))}";\n${css}`;
+}
+function normalizeConfigDirective(css, config) {
+	if (!config || !/@config\s+/.test(css)) return css;
+	return css.replace(/@config\s+(["'])(.+?)\1\s*;?/, `@config "${quoteCssString(toCssPath(config))}";`);
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/source-files.ts
+const SOURCE_STYLE_EXTENSIONS = [
+	".vue",
+	".uvue",
+	".nvue",
+	".css",
+	".scss",
+	".sass",
+	".less",
+	".styl",
+	".stylus",
+	".wxss",
+	".acss",
+	".jxss",
+	".ttss",
+	".qss"
+];
+const SFC_STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+function stripStyleExtension(file) {
+	return file.replace(/[?#].*$/, "").replace(/\.(?:wx|ac|jx|tt|q|c|ty)?ss$/i, "");
+}
+function createSourceStylePathCandidates(file, sourceOptions) {
+	const bases = [
+		sourceOptions.projectRoot,
+		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();
+	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);
+		}
+	};
+	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;
+		for (const base of bases) for (const sourceRoot of ["", "src"]) {
+			const prefix = sourceRoot ? node_path.default.resolve(base, sourceRoot, relativeFile) : node_path.default.resolve(base, relativeFile);
+			for (const extension of SOURCE_STYLE_EXTENSIONS) candidates.add(`${prefix}${extension}`);
+		}
+	}
+	return [...candidates];
+}
+function extractStyleDirectiveSources(source) {
+	const styleSources = [];
+	SFC_STYLE_BLOCK_RE.lastIndex = 0;
+	let match = SFC_STYLE_BLOCK_RE.exec(source);
+	while (match !== null) {
+		const styleSource = match[1] ?? "";
+		if (hasTailwindSourceDirectives(styleSource)) styleSources.push(styleSource);
+		match = SFC_STYLE_BLOCK_RE.exec(source);
+	}
+	if (styleSources.length > 0) return styleSources;
+	return hasTailwindSourceDirectives(source) ? [source] : [];
+}
+function resolveSourceSideCssEntrySource(file, sourceOptions, resolveOptions = {}) {
+	for (const sourceFile of createSourceStylePathCandidates(file, sourceOptions)) {
+		if (!(0, node_fs.existsSync)(sourceFile)) continue;
+		try {
+			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,
+					file: sourceFile
+				};
+			}
+		} catch {
+			continue;
+		}
+	}
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/source-resolver.ts
+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,
+		packageName: sourceOptions.packageName,
+		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));
+}
+function resolveExistingConfigPath(config, configRequest, file, sourceOptions) {
+	if (config && (0, node_fs.existsSync)(config)) return config;
+	if (!configRequest || node_path.default.isAbsolute(configRequest)) return sourceOptions.config;
+	const outputDir = node_path.default.dirname(file.replace(/[?#].*$/, ""));
+	const baseCandidates = [
+		sourceOptions.projectRoot,
+		sourceOptions.cwd,
+		node_process.default.cwd()
+	].filter((item) => typeof item === "string" && item.length > 0);
+	for (const base of baseCandidates) {
+		const candidates = [
+			node_path.default.resolve(base, configRequest),
+			node_path.default.resolve(base, "src", configRequest),
+			node_path.default.resolve(base, outputDir, configRequest),
+			node_path.default.resolve(base, "src", outputDir, configRequest)
+		];
+		for (const candidate of candidates) if ((0, node_fs.existsSync)(candidate)) return candidate;
+	}
+	return sourceOptions.config;
+}
+function canResolveSourceSideCssEntry(file, cssHandlerOptions) {
+	const from = resolvePostcssFromOption(cssHandlerOptions);
+	if (!from || !node_path.default.isAbsolute(from)) return node_path.default.isAbsolute(file);
+	return true;
+}
+function shouldResolveSourceSideCssEntry(rawSource) {
+	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();
+}
+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;
+	const normalizedRawSource = normalizeCssSourceForCompare(rawSource);
+	const outputStem = getOutputFileStem(file);
+	const matchingEntry = cssEntries.find((cssEntry) => {
+		if (!(0, node_fs.existsSync)(cssEntry)) return false;
+		try {
+			if (normalizeCssSourceForCompare((0, node_fs.readFileSync)(cssEntry, "utf8")) === normalizedRawSource) return true;
+			return outputStem.length > 0 && getOutputFileStem(cssEntry) === outputStem;
+		} catch {
+			return false;
+		}
+	});
+	if (!matchingEntry) return;
+	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_v3_engine.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher);
+	} catch {
+		return;
+	}
+}
+function hasConfiguredTailwindV4CssSource(sourceOptions) {
+	return Boolean(sourceOptions?.css) || Boolean(sourceOptions?.cssSources?.length);
+}
+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: require_v3_engine.resolveTailwindV4CssSourceBase(cssSource, sourceBaseFallback),
+		sourceCss: cssSource.css
+	});
+}
+async function resolveTailwindV4CssSourceEntries(cssSource, sourceOptions) {
+	if (typeof cssSource.css !== "string" || cssSource.css.length === 0) return;
+	const sourceBase = require_v3_engine.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, selectionOptions) {
+	const base = resolveCssSourceBase(file, cssHandlerOptions);
+	const cssEntrySource = resolveCssEntrySource(rawSource, base, {
+		importFallback: generatorOptions?.importFallback ?? false,
+		removeConfig: majorVersion === 3
+	});
+	if (majorVersion === 3) {
+		const sourceOptions = require_v3_engine.resolveTailwindV3SourceOptionsFromPatcher(runtimeState.twPatcher);
+		const mergedSourceOptions = require_v3_engine.omitUndefined({
+			...sourceOptions,
+			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 = 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,
+			...config ? { config } : {}
+		});
+	}
+	const sourceOptions = tryResolveTailwindV4SourceOptions(runtimeState);
+	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 matchedCssEntrySource = sourceOptions && cssEntrySource ? await resolveMatchingTailwindV4CssEntry(rawSource, file, sourceOptions) : void 0;
+	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 ?? 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_v3_engine.resolveTailwindV4SourceFromPatcher(runtimeState.twPatcher);
+		return generatorOptions?.config ? {
+			...source,
+			css: prependConfigDirective(source.css, generatorOptions.config)
+		} : source;
+	}
+	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, selectionOptions) {
+	const cssEntrySource = resolveCssEntrySource(rawSource, resolveCssSourceBase(file, cssHandlerOptions), {
+		importFallback: generatorOptions?.importFallback ?? false,
+		removeConfig: majorVersion === 3
+	});
+	if (majorVersion !== 4 || cssEntrySource && !cssHandlerOptions.isMainChunk) {
+		const resolved = await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions);
+		return resolved ? [resolved] : [];
+	}
+	let sourceOptions;
+	try {
+		sourceOptions = require_v3_engine.omitUndefined({
+			...require_v3_engine.resolveTailwindV4SourceOptionsFromPatcher(runtimeState.twPatcher),
+			...resolveCssHandlerSourceOptions(cssHandlerOptions)
+		});
+	} catch {
+		const resolved = await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions);
+		return resolved ? [resolved] : [];
+	}
+	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])];
+		const resolved = await resolveGeneratorSource(majorVersion, runtimeState, rawSource, file, cssHandlerOptions, generatorOptions, selectionOptions);
+		return resolved ? [resolved] : [];
+	}
+	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
+const LEGACY_CONTAINER_COMPAT_CSS = [
+	".container {",
+	"  width: 100%;",
+	"}",
+	"@media (min-width: 40rem) {",
+	"  .container {",
+	"    max-width: 40rem;",
+	"  }",
+	"}",
+	"@media (min-width: 48rem) {",
+	"  .container {",
+	"    max-width: 48rem;",
+	"  }",
+	"}",
+	"@media (min-width: 64rem) {",
+	"  .container {",
+	"    max-width: 64rem;",
+	"  }",
+	"}",
+	"@media (min-width: 80rem) {",
+	"  .container {",
+	"    max-width: 80rem;",
+	"  }",
+	"}",
+	"@media (min-width: 96rem) {",
+	"  .container {",
+	"    max-width: 96rem;",
+	"  }",
+	"}"
+].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 countUnclosedBlocks(source) {
+	let depth = 0;
+	let quote;
+	let inComment = false;
+	let escaped = false;
+	for (let index = 0; index < source.length; index += 1) {
+		const char = source[index];
+		const next = source[index + 1];
+		if (inComment) {
+			if (char === "*" && next === "/") {
+				inComment = false;
+				index += 1;
+			}
+			continue;
+		}
+		if (quote) {
+			if (escaped) {
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "/" && next === "*") {
+			inComment = true;
+			index += 1;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "{") depth += 1;
+		else if (char === "}" && depth > 0) depth -= 1;
+	}
+	return depth;
+}
+function closeTrailingUnclosedBlocks(source) {
+	try {
+		postcss.default.parse(source);
+		return source;
+	} catch (error) {
+		if (error.reason !== "Unclosed block") return source;
+		const unclosedBlocks = countUnclosedBlocks(source);
+		return unclosedBlocks > 0 ? `${source}${"}".repeat(unclosedBlocks)}` : source;
+	}
+}
+function removeTailwindApplyRules(rawSource) {
+	try {
+		const root = postcss.default.parse(rawSource);
+		let removed = false;
+		root.walkAtRules("apply", (rule) => {
+			const parent = rule.parent;
+			if (parent?.type === "rule") parent.remove();
+			else rule.remove();
+			removed = true;
+		});
+		root.walkAtRules((rule) => {
+			if (rule.nodes && rule.nodes.length === 0) rule.remove();
+		});
+		return removed ? root.toString() : rawSource;
+	} catch {
+		return rawSource;
+	}
+}
+function resolveLegacyCompatCssSource(rawSource) {
+	const cached = legacyCompatSourceCache.get(rawSource);
+	if (cached !== void 0) return cached;
+	const resolved = closeTrailingUnclosedBlocks((0, _weapp_tailwindcss_postcss.removeUnsupportedMiniProgramAtRules)(removeTailwindApplyRules(removeTailwindSourceDirectives(closeTrailingUnclosedBlocks(stripTailwindBanners(rawSource))))));
+	setLimitedCacheValue(legacyCompatSourceCache, rawSource, resolved);
+	return resolved;
+}
+function hasContainerConfigToken(rawSource) {
+	return rawSource.includes("@config") && /\bcontainer\b/.test(rawSource);
+}
+function hasConfiguredContainerCompat(rawSource, file, cssHandlerOptions) {
+	if (hasContainerConfigToken(rawSource)) return true;
+	const cssEntrySource = resolveCssEntrySource(rawSource, resolveCssSourceBase(file, cssHandlerOptions));
+	if (!cssEntrySource?.config) return false;
+	try {
+		return /\bcontainer\b/.test((0, node_fs.readFileSync)(cssEntrySource.config, "utf8"));
+	} catch {
+		return false;
+	}
+}
+function hasConfiguredContainerCompatSource(source) {
+	if (hasContainerConfigToken(source.css)) return true;
+	const cssEntrySource = resolveCssEntrySource(source.css, source.base);
+	if (cssEntrySource?.config) try {
+		if (/\bcontainer\b/.test((0, node_fs.readFileSync)(cssEntrySource.config, "utf8"))) return true;
+	} catch {}
+	if ("config" in source && source.config) try {
+		if (/\bcontainer\b/.test((0, node_fs.readFileSync)(source.config, "utf8"))) return true;
+	} catch {}
+	return false;
+}
+function hasConfiguredContainerCompatSources(sources) {
+	return sources.some((source) => hasConfiguredContainerCompatSource(source));
+}
+async function appendLegacyCompatCss(css, rawSource, generatorTarget, styleHandler, cssHandlerOptions, generatorStyleOptions) {
+	const compatSource = removeGeneratedSelectorCompatCss(resolveLegacyCompatCssSource(rawSource), css);
+	if (compatSource.trim().length === 0) return css;
+	if (generatorTarget !== "weapp") return createCssAppend(css, 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((0, _weapp_tailwindcss_postcss.removeUnsupportedMiniProgramAtRules)(compatCss), css), css);
+	if (cleanedCompatCss.trim().length === 0) return css;
+	return createCssAppend(css, cleanedCompatCss);
+}
+async function appendLegacyContainerCompatCss(css, rawSource, file, runtime, configuredContainerCompat, generatorTarget, styleHandler, cssHandlerOptions, generatorStyleOptions) {
+	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 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((0, _weapp_tailwindcss_postcss.removeUnsupportedMiniProgramAtRules)(compatCss), css);
+	if (cleanedCompatCss.trim().length === 0) return css;
+	return createCssAppend(css, cleanedCompatCss);
+}
+//#endregion
+//#region src/bundlers/shared/generator-css/legacy-units.ts
+const CSS_LENGTH_UNIT_RE = /(?:^|[\s(,])[-+]?(?:\d+|\d*\.\d+)(?:px|rem)\b/i;
+const RPX_UNIT_RE = /(?:^|[\s(,])[-+]?(?:\d+|\d*\.\d+)rpx\b/i;
+function createLegacyDeclarationValueMap(css) {
+	const values = /* @__PURE__ */ new Map();
+	postcss.default.parse(css).walkRules((rule) => {
+		if (!rule.selectors || rule.selectors.length === 0) return;
+		for (const selector of rule.selectors) {
+			const normalizedSelectors = normalizeCompatSelectors(selector);
+			rule.walkDecls((decl) => {
+				if (RPX_UNIT_RE.test(decl.value)) for (const normalizedSelector of normalizedSelectors) values.set(`${normalizedSelector}\n${decl.prop}`, decl.value);
+			});
+		}
+	});
+	return values;
+}
+function inheritLegacyUnitConvertedDeclarations(css, legacyCss) {
+	try {
+		const legacyValues = createLegacyDeclarationValueMap(legacyCss);
+		if (legacyValues.size === 0) return css;
+		const root = postcss.default.parse(css);
+		let changed = false;
+		root.walkRules((rule) => {
+			if (!rule.selectors || rule.selectors.length === 0) return;
+			const selectors = rule.selectors.flatMap((selector) => normalizeCompatSelectors(selector));
+			if (selectors.length === 0) return;
+			rule.walkDecls((decl) => {
+				if (!CSS_LENGTH_UNIT_RE.test(decl.value)) return;
+				for (const selector of selectors) {
+					const legacyValue = legacyValues.get(`${selector}\n${decl.prop}`);
+					if (legacyValue && legacyValue !== decl.value) {
+						decl.value = legacyValue;
+						changed = true;
+						return;
+					}
+				}
+			});
+		});
+		return changed ? root.toString() : css;
+	} catch {
+		return css;
+	}
+}
+//#endregion
+//#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, majorVersion, cssPreflight, options = {}) {
+	if (target !== "weapp") return css;
+	return (0, _weapp_tailwindcss_postcss.finalizeMiniProgramCss)(css, {
+		cssPreflight: majorVersion === 4 && options.injectPreflight !== false ? 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 shouldScanTailwindV4Sources(majorVersion, target, generatorRuntime, isolateCssSource) {
+	if (majorVersion !== 4 || isolateCssSource) return false;
+	return target === "web" || generatorRuntime.size === 0;
+}
+function shouldAppendWebBundleCssFallback(target, options) {
+	return target === "web" && !options.hasMatchedCssSourceFile && !options.hasSourceDirectives;
+}
+function isEmptyCssSourceOrderParts(parts) {
+	return parts.before.trim().length === 0 && parts.after.trim().length === 0;
+}
+function resolveGeneratorStyleOptions(opts, cssHandlerOptions, generatorStyleOptions) {
+	const preflightStyleOptions = {
+		cssPreflight: opts.cssPreflight,
+		cssPreflightRange: opts.cssPreflightRange
+	};
+	return {
+		...require_precheck.resolveStyleOptionsFromContext(opts),
+		atRules: opts.atRules,
+		uniAppXCssTarget: opts.uniAppXCssTarget,
+		uniAppXUnsupported: opts.uniAppXUnsupported,
+		...cssHandlerOptions,
+		...preflightStyleOptions,
+		...generatorStyleOptions
+	};
+}
+function isLocalImportRequest(request) {
+	return request.length > 0 && !request.startsWith("tailwindcss") && !request.startsWith("weapp-tailwindcss") && !request.startsWith("data:") && !REMOTE_IMPORT_RE.test(request);
+}
+function isCommentOnlyCss(source) {
+	try {
+		const root = postcss.default.parse(source);
+		return root.nodes.length > 0 && root.nodes.every((node) => node.type === "comment");
+	} catch {
+		return false;
+	}
+}
+function stripTailwindSourceMediaFragments(source) {
+	return source.replace(/^\s*@media\s+source\([^)]*\)\s*\{\s*$/gm, "").replace(/^\s*\}\s*(?=@(?:source|theme|config|plugin|utility|variant|custom-variant)\b)/gm, "").replace(/^\s*\}\s*\/\*\s*source\([^)]*\)\s*\*\/\s*$/gm, "");
+}
+function stripLeadingTailwindSourceMediaCloseFragment(source) {
+	return source.replace(/^\s*\}\s*(?:\n|$)/, "");
+}
+function stripUnmatchedTailwindSourceMediaCloseFragments(source) {
+	try {
+		postcss.default.parse(source);
+		return source;
+	} catch {
+		return stripLeadingTailwindSourceMediaCloseFragment(source).replace(/\s*\}\s*$/, "");
+	}
+}
+function createCssSourceOrderAppend(base, extra) {
+	if (!base) return extra;
+	if (!extra) return base;
+	if (/\s$/.test(base) || /^\s/.test(extra)) return `${base}${extra}`;
+	return `${base}\n${extra}`;
+}
+function splitRawSourceByGeneratedCssOrder(rawSource, rawTailwindCss) {
+	const placeholderParts = splitGeneratorPlaceholderCssBySourceOrder(rawSource, rawTailwindCss);
+	if (placeholderParts) return placeholderParts;
+	const exactParts = splitTailwindV4GeneratedCssBySourceOrder(rawSource, rawTailwindCss);
+	if (exactParts) return exactParts;
+	return splitTailwindGeneratedCssByBanner(rawSource);
+}
+async function transformGeneratorUserCss(source, options) {
+	if (source.trim().length === 0) return "";
+	const cleanedSource = removeTailwindSourceDirectives(stripUnmatchedTailwindSourceMediaCloseFragments(stripTailwindSourceMediaFragments(source)), { importFallback: options.importFallback });
+	if (cleanedSource.trim().length === 0) return "";
+	const userSource = stripUnmatchedTailwindSourceMediaCloseFragments(removeTailwindSourceDirectives(stripUnmatchedTailwindSourceMediaCloseFragments(stripTailwindSourceMediaFragments(options.generatorTarget === "weapp" ? (0, _weapp_tailwindcss_postcss.removeUnsupportedMiniProgramAtRules)(cleanedSource) : cleanedSource)), { importFallback: options.importFallback }));
+	if (userSource.trim().length === 0) return "";
+	if (isCommentOnlyCss(userSource)) return userSource;
+	if (options.generatorTarget !== "weapp") return userSource;
+	const { css } = await options.styleHandler(userSource, {
+		...options.generatorStyleOptions,
+		...options.cssUserHandlerOptions
+	});
+	return (0, _weapp_tailwindcss_postcss.removeUnsupportedMiniProgramAtRules)(css);
+}
+function isPureLocalCssImportWrapper(css) {
+	let hasImport = false;
+	try {
+		const root = postcss.default.parse(css);
+		for (const node of root.nodes) {
+			if (node.type === "comment") continue;
+			if (node.type !== "atrule" || node.name !== "import") return false;
+			const request = parseImportRequest(node.params);
+			if (!request || !isLocalImportRequest(request)) return false;
+			hasImport = true;
+		}
+	} catch {
+		return false;
+	}
+	return hasImport;
+}
+function cleanLocalCssImportWrapperTailwindDirectives(css) {
+	let hasLocalImport = false;
+	let hasTailwindDirective = false;
+	try {
+		const root = postcss.default.parse(css);
+		for (const node of root.nodes) {
+			if (node.type === "comment") continue;
+			if (node.type === "atrule" && node.name === "import") {
+				const request = parseImportRequest(node.params);
+				if (!request || !isLocalImportRequest(request)) return;
+				hasLocalImport = true;
+				continue;
+			}
+			if (node.type === "atrule" && node.name === "source") {
+				hasTailwindDirective = true;
+				continue;
+			}
+			return;
+		}
+	} catch {
+		return;
+	}
+	return hasLocalImport && hasTailwindDirective ? prefixLocalCssImportsWithWebpackIgnore(removeTailwindSourceDirectives(css)) : void 0;
+}
+function prefixLocalCssImportsWithWebpackIgnore(css) {
+	try {
+		const root = postcss.default.parse(css);
+		root.walkAtRules("import", (atRule) => {
+			const request = parseImportRequest(atRule.params);
+			if (request && isLocalImportRequest(request)) atRule.raws.before = `${atRule.raws.before ?? ""}/* webpackIgnore: true */\n`;
+		});
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+async function generateCssByGenerator(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 = stripUnmatchedTailwindSourceMediaCloseFragments(stripTailwindSourceMediaFragments(normalizeTailwindSourceDirectives(rawSource, { importFallback: generatorOptions.importFallback })));
+	const cleanedLocalImportWrapper = cleanLocalCssImportWrapperTailwindDirectives(effectiveRawSource);
+	if (cleanedLocalImportWrapper !== void 0) return {
+		css: generatorOptions.target === "weapp" ? (0, _weapp_tailwindcss_postcss.removeUnsupportedMiniProgramAtRules)(cleanedLocalImportWrapper) : cleanedLocalImportWrapper,
+		target: generatorOptions.target,
+		source: "generator",
+		dependencies: []
+	};
+	if (isPureLocalCssImportWrapper(effectiveRawSource)) return;
+	const hasGeneratedCss = hasTailwindGeneratedCss(effectiveRawSource);
+	const hasSourceDirectives = hasTailwindSourceDirectives(effectiveRawSource, { importFallback: generatorOptions.importFallback });
+	const hasGeneratedMarkers = hasTailwindGeneratedCssMarkers(effectiveRawSource);
+	const shouldGenerateCurrentCss = hasGeneratedCss || hasGeneratedMarkers || hasSourceDirectives || cssHandlerOptions.isMainChunk;
+	if (!SUPPORTED_GENERATOR_MAJOR_VERSIONS.has(majorVersion ?? 0) || !shouldGenerateCurrentCss || majorVersion === 3 && !hasSourceDirectives && !hasGeneratedCss && !hasGeneratedMarkers) return;
+	try {
+		await runtimeState.readyPromise;
+		const currentCssCandidates = majorVersion === 4 ? await (0, tailwindcss_patch.extractSourceCandidates)(effectiveRawSource, "css") : [];
+		const runtimeWithCurrentCss = currentCssCandidates.length > 0 ? new Set([...runtime, ...currentCssCandidates]) : runtime;
+		const sources = await resolveGeneratorSources(majorVersion, runtimeState, effectiveRawSource, file, cssHandlerOptions, generatorOptions, {
+			getSourceCandidatesForEntries,
+			runtime: runtimeWithCurrentCss
+		});
+		const generatorStyleOptions = resolveGeneratorStyleOptions(opts, cssHandlerOptions, generatorOptions.styleOptions);
+		const configuredContainerCompat = hasConfiguredContainerCompatSources(sources);
+		const generatedResults = await Promise.all(sources.map(async (source) => {
+			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, runtimeWithCurrentCss, {
+				cssHandlerOptions,
+				isolateCssSource
+			}) : runtimeWithCurrentCss;
+			const generatorRuntime = majorVersion === 4 && generatorOptions.target === "weapp" ? require_v3_engine.filterUnsupportedMiniProgramTailwindV4Candidates(sourceRuntime) : sourceRuntime;
+			return generator.generate({
+				candidates: generatorRuntime,
+				incrementalCache: majorVersion === 3 || majorVersion === 4,
+				scanSources: shouldScanTailwindV4Sources(majorVersion, generatorOptions.target, generatorRuntime, isolateCssSource),
+				styleOptions: generatorStyleOptions,
+				tailwindcssV3Compatibility: generatorOptions.tailwindcssV3Compatibility,
+				target: generatorOptions.target
+			});
+		}));
+		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, { injectPreflight: false })) : options.previousCss,
+				target: generated.target,
+				source: "generator",
+				dependencies: generated.dependencies,
+				incremental: true
+			};
+		}
+		const hasMatchedCssSourceFile = sources.some((source) => source.__weappTailwindcssMeta?.matchedCssSourceFile);
+		const orderedExtraCss = hasMatchedCssSourceFile ? splitTailwindV4GeneratedCssBySourceOrder(effectiveRawSource, generated.rawCss) : splitRawSourceByGeneratedCssOrder(effectiveRawSource, generated.rawCss);
+		if (orderedExtraCss) {
+			let css = stripTailwindBanner(generated.css);
+			if (generated.target === "weapp") css = inheritLegacyUnitConvertedDeclarations(css, effectiveRawSource);
+			const userCssOptions = {
+				generatorTarget: generated.target,
+				generatorStyleOptions,
+				cssUserHandlerOptions,
+				styleHandler,
+				importFallback: generatorOptions.importFallback
+			};
+			const beforeUserCss = await transformGeneratorUserCss(orderedExtraCss.before, userCssOptions);
+			const afterUserCss = await transformGeneratorUserCss(orderedExtraCss.after, userCssOptions);
+			css = createCssSourceOrderAppend(createCssSourceOrderAppend(beforeUserCss, css), afterUserCss);
+			if (isEmptyCssSourceOrderParts(orderedExtraCss) && shouldAppendWebBundleCssFallback(generated.target, {
+				hasSourceDirectives,
+				hasMatchedCssSourceFile
+			})) {
+				const userCss = await transformGeneratorUserCss(effectiveRawSource, userCssOptions);
+				css = createCssSourceOrderAppend(css, userCss);
+			}
+			if (generated.target === "weapp") {
+				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, majorVersion, opts.cssPreflight),
+				target: generated.target,
+				source: "generator",
+				dependencies: generated.dependencies
+			};
+		}
+		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 (hasMatchedCssSourceFile || generated.target === "web") {
+			if (shouldAppendWebBundleCssFallback(generated.target, {
+				hasSourceDirectives,
+				hasMatchedCssSourceFile
+			})) {
+				const userCss = await transformGeneratorUserCss(effectiveRawSource, {
+					generatorTarget: generated.target,
+					generatorStyleOptions,
+					cssUserHandlerOptions,
+					styleHandler,
+					importFallback: generatorOptions.importFallback
+				});
+				css = createCssSourceOrderAppend(css, userCss);
+			}
+			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, majorVersion, opts.cssPreflight),
+			target: generated.target,
+			source: "generator",
+			dependencies: generated.dependencies
+		};
+	} catch (error) {
+		debug("tailwind direct css generation failed: %s %O", file, error);
+		throw error;
+	}
+}
+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), { 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);
+		return (await generator.generate({
+			candidates,
+			target: "tailwind"
+		})).classSet;
+	}));
+	const classSet = new Set(classSets.flatMap((item) => [...item]));
+	debug("tailwind generator validated candidates: %s candidates=%d classSet=%d", file, candidates.size, classSet.size);
+	return classSet;
+}
+//#endregion
+//#region src/bundlers/shared/hmr-timing.ts
+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)),
+		...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_v3_engine.createDebug("[vite:runtime-set] ");
+const EXTENSION_DOT_PREFIX_RE = /^\./;
+const VENDOR_CHUNK_BASENAME_RE = /^(?:vendor|vendors|chunk-vendors|common_vendor)(?:[.-]|$)/i;
+const COMMON_VENDOR_CHUNK_RE = /^(?:common|static|assets|chunks?)\/(?:vendor|vendors|chunk-vendors|common_vendor|runtime)(?:[.-]|$)/i;
+function toPosixPath(value) {
+	return value.split("\\").join("/");
+}
+function isDependencyModuleId(id) {
+	const normalized = toPosixPath(id);
+	return normalized.includes("/node_modules/") || normalized.includes("/.pnpm/") || normalized.includes("/node_modules_");
+}
+function collectChunkModuleIds(entry) {
+	if (entry.output.type !== "chunk") return [];
+	return [...entry.output.moduleIds, ...Object.keys(entry.output.modules ?? {})].filter((id, index, ids) => ids.indexOf(id) === index);
+}
+function isKnownVendorChunkFile(file) {
+	const normalized = toPosixPath(file).replace(/^\.\//, "");
+	const basename = normalized.slice(normalized.lastIndexOf("/") + 1);
+	return VENDOR_CHUNK_BASENAME_RE.test(basename) || COMMON_VENDOR_CHUNK_RE.test(normalized) || normalized.includes("/node_modules/") || normalized.includes("/node_modules_");
+}
+function isDependencyOnlyChunk(entry) {
+	if (entry.output.type !== "chunk") return false;
+	if (entry.output.isEntry || entry.output.isDynamicEntry || entry.output.isImplicitEntry) return false;
+	const moduleIds = collectChunkModuleIds(entry);
+	return moduleIds.length > 0 && moduleIds.every(isDependencyModuleId);
+}
+function isRuntimeCandidateEntry(entry) {
+	if (entry.type === "html") return true;
+	if (entry.type !== "js") return false;
+	if (isDependencyOnlyChunk(entry)) return false;
+	if (!isKnownVendorChunkFile(entry.file)) return true;
+	if (entry.output.type !== "chunk") return false;
+	if (entry.output.facadeModuleId && !isDependencyModuleId(entry.output.facadeModuleId)) return true;
+	return collectChunkModuleIds(entry).some((id) => !isDependencyModuleId(id));
+}
+function createExtractOptions(context, source) {
+	return {
+		cwd: context.projectRoot,
+		base: context.base,
+		baseFallbacks: context.baseFallbacks,
+		css: context.css,
+		content: source,
+		extension: "html"
+	};
+}
+function createRuntimeEntries(snapshot) {
+	return snapshot.entries.filter(isRuntimeCandidateEntry);
+}
+function collectChangedRuntimeFiles(snapshot) {
+	return new Set([...snapshot.runtimeAffectingChangedByType.html, ...snapshot.runtimeAffectingChangedByType.js]);
+}
+function resolveEntryExtension(entry) {
+	if (entry.type === "html") return "html";
+	const ext = entry.file.split(/[?#]/, 1)[0]?.split(".").pop()?.replace(EXTENSION_DOT_PREFIX_RE, "") ?? "";
+	if (ext.length > 0) return ext;
+	return "js";
+}
+function createCandidateValidationSource(candidates) {
+	return [...new Set(candidates)].sort().join("\n");
+}
+function removeCandidateSet(candidateCountByClass, candidates) {
+	for (const className of candidates) {
+		const count = candidateCountByClass.get(className);
+		if (count == null) continue;
+		if (count <= 1) {
+			candidateCountByClass.delete(className);
+			continue;
+		}
+		candidateCountByClass.set(className, count - 1);
+	}
+}
+function addCandidateSet(candidateCountByClass, candidates) {
+	for (const className of candidates) {
+		const nextCount = (candidateCountByClass.get(className) ?? 0) + 1;
+		candidateCountByClass.set(className, nextCount);
+	}
+}
+function createRuntimeClassSet(baseClassSet, candidateCountByClass) {
+	return new Set([...baseClassSet, ...candidateCountByClass.keys()]);
+}
+function createNonSourceBaseClassSet(baseClassSet, candidateCountByClass) {
+	const nextBaseClassSet = new Set(baseClassSet);
+	for (const candidate of candidateCountByClass.keys()) nextBaseClassSet.delete(candidate);
+	return nextBaseClassSet;
+}
+function createBundleRuntimeClassSetManager(options = {}) {
+	const customExtractCandidates = options.extractCandidates;
+	const extractCandidates = customExtractCandidates ?? tailwindcss_patch.extractValidCandidates;
+	const extractRawCandidates = options.extractRawCandidates ?? tailwindcss_patch.extractRawCandidatesWithPositions;
+	let baseClassSet = /* @__PURE__ */ new Set();
+	const candidateCountByClass = /* @__PURE__ */ new Map();
+	const candidatesByFile = /* @__PURE__ */ new Map();
+	const candidateValidityCache = /* @__PURE__ */ new Map();
+	let runtimeSignature;
+	let validationContext;
+	let designSystemPromise;
+	async function reset() {
+		baseClassSet = /* @__PURE__ */ new Set();
+		candidateCountByClass.clear();
+		candidatesByFile.clear();
+		candidateValidityCache.clear();
+		runtimeSignature = void 0;
+		validationContext = void 0;
+		designSystemPromise = void 0;
+	}
+	async function resolveValidationContextCached(patcher) {
+		if (!validationContext) validationContext = await require_v3_engine.resolveTailwindV4SourceFromPatcher(patcher);
+		return validationContext;
+	}
+	async function loadDesignSystem(context) {
+		if (!designSystemPromise) designSystemPromise = (0, tailwindcss_patch.loadTailwindV4DesignSystem)(context);
+		return designSystemPromise;
+	}
+	function populateCandidateValidityCacheFromDesignSystem(designSystem, unknownCandidates) {
+		const parsedCandidates = [...unknownCandidates].filter((candidate) => designSystem.parseCandidate(candidate).length > 0);
+		const cssByCandidate = parsedCandidates.length > 0 ? designSystem.candidatesToCss(parsedCandidates) : [];
+		const validCandidates = /* @__PURE__ */ new Set();
+		for (let index = 0; index < parsedCandidates.length; index += 1) {
+			const candidate = parsedCandidates[index];
+			const css = cssByCandidate[index];
+			if (candidate && typeof css === "string" && css.trim().length > 0) validCandidates.add(candidate);
+		}
+		for (const candidate of unknownCandidates) candidateValidityCache.set(candidate, validCandidates.has(candidate));
+	}
+	async function validateUnknownCandidates(patcher, unknownCandidates) {
+		if (unknownCandidates.size === 0) return;
+		if (patcher.majorVersion === 3 && !customExtractCandidates) {
+			for (const candidate of unknownCandidates) candidateValidityCache.set(candidate, true);
+			return;
+		}
+		const context = await resolveValidationContextCached(patcher);
+		if (!customExtractCandidates) try {
+			populateCandidateValidityCacheFromDesignSystem(await loadDesignSystem(context), unknownCandidates);
+			return;
+		} catch (error) {
+			debug("incremental design-system validation failed: %O", error);
+			designSystemPromise = void 0;
+			throw error;
+		}
+		const source = createCandidateValidationSource(unknownCandidates);
+		const validCandidates = new Set(await extractCandidates(createExtractOptions(context, source)));
+		for (const candidate of unknownCandidates) candidateValidityCache.set(candidate, validCandidates.has(candidate));
+	}
+	async function extractEntryRawCandidates(entry) {
+		const matches = await extractRawCandidates(entry.source, resolveEntryExtension(entry));
+		const candidates = /* @__PURE__ */ new Set();
+		for (const match of matches) {
+			const candidate = match?.rawCandidate;
+			if (typeof candidate === "string" && candidate.length > 0) candidates.add(candidate);
+		}
+		return candidates;
+	}
+	async function sync(patcher, snapshot, options = {}) {
+		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);
+			await reset();
+		}
+		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 = canUseBaseWithoutInitialFullScan ? [...collectChangedRuntimeFiles(snapshot)] : fullRebuild ? [...runtimeEntriesByFile.keys()] : [...collectChangedRuntimeFiles(snapshot)];
+		if (changedRuntimeFiles.length === 0) {
+			if (nextBaseClassSet) baseClassSet = canUseBaseWithoutInitialFullScan ? new Set(nextBaseClassSet) : createNonSourceBaseClassSet(nextBaseClassSet, candidateCountByClass);
+			return createRuntimeClassSet(baseClassSet, candidateCountByClass);
+		}
+		const rawCandidatesByFile = /* @__PURE__ */ new Map();
+		const unknownCandidates = /* @__PURE__ */ new Set();
+		await Promise.all(changedRuntimeFiles.map(async (file) => {
+			const entry = runtimeEntriesByFile.get(file);
+			if (!entry) return;
+			const candidates = await extractEntryRawCandidates(entry);
+			rawCandidatesByFile.set(file, candidates);
+			for (const candidate of candidates) if (!candidateValidityCache.has(candidate)) unknownCandidates.add(candidate);
+		}));
+		await validateUnknownCandidates(patcher, unknownCandidates);
+		let rawCandidateCount = 0;
+		for (const file of changedRuntimeFiles) {
+			const nextRawCandidates = rawCandidatesByFile.get(file);
+			const previousCandidates = candidatesByFile.get(file);
+			if (previousCandidates) removeCandidateSet(candidateCountByClass, previousCandidates);
+			if (!nextRawCandidates || nextRawCandidates.size === 0) {
+				candidatesByFile.delete(file);
+				continue;
+			}
+			rawCandidateCount += nextRawCandidates.size;
+			const nextCandidates = new Set([...nextRawCandidates].filter((candidate) => candidateValidityCache.get(candidate) === true));
+			if (nextCandidates.size === 0) {
+				candidatesByFile.delete(file);
+				continue;
+			}
+			addCandidateSet(candidateCountByClass, nextCandidates);
+			candidatesByFile.set(file, nextCandidates);
+		}
+		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);
+	}
+	return {
+		sync,
+		reset
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createBundleRuntimeClassSetManager", {
+	enumerable: true,
+	get: function() {
+		return createBundleRuntimeClassSetManager;
+	}
+});
+Object.defineProperty(exports, "createHmrTimingRecorder", {
+	enumerable: true,
+	get: function() {
+		return createHmrTimingRecorder;
+	}
+});
+Object.defineProperty(exports, "emitHmrTiming", {
+	enumerable: true,
+	get: function() {
+		return emitHmrTiming;
+	}
+});
+Object.defineProperty(exports, "generateCssByGenerator", {
+	enumerable: true,
+	get: function() {
+		return generateCssByGenerator;
+	}
+});
+Object.defineProperty(exports, "hasTailwindGeneratedCssMarkers", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindGeneratedCssMarkers;
+	}
+});
+Object.defineProperty(exports, "hasTailwindRootDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindRootDirectives;
+	}
+});
+Object.defineProperty(exports, "hasTailwindSourceDirectives", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindSourceDirectives;
+	}
+});
+Object.defineProperty(exports, "normalizeTailwindSourceForGenerator", {
+	enumerable: true,
+	get: function() {
+		return normalizeTailwindSourceForGenerator;
+	}
+});
+Object.defineProperty(exports, "processCachedTask", {
+	enumerable: true,
+	get: function() {
+		return processCachedTask;
+	}
+});
+Object.defineProperty(exports, "validateCandidatesByGenerator", {
+	enumerable: true,
+	get: function() {
+		return validateCandidatesByGenerator;
+	}
+});