weapp-tailwindcss 5.0.3 → 5.0.4

package/dist/vite-DS4H5d0f.mjs

@@ -0,0 +1,2616 @@
+import { E as normalizeTailwindConfigDirectives, I as hasTailwindGeneratedCssMarkers, J as filterUnsupportedMiniProgramTailwindV4Candidates, O as normalizeTailwindSourceForGenerator, T as hasTailwindSourceDirectives, _ as resolveViteSourceScanEntries, ct as createDebug, dt as findTailwindConfig, ft as resolveTailwindcssOptions, g as resolveTailwindV4EntriesFromCssCached, gt as findNearestPackageRoot, ht as omitUndefined, l as getRuntimeClassSetSignature, m as discoverTailwindV4CssEntries, ot as resolveTailwindV4CssSourceBase, p as createViteSourceScanMatcher, v as resolveViteTailwindV4CssDependencies, w as hasTailwindRootDirectives } from "./v3-engine-BCUGX3gX.mjs";
+import { i as normalizeWeappTailwindcssGeneratorOptions } from "./generator-DRHWC1t-.mjs";
+import { _ as collectRuntimeClassSet, a as vitePluginName, b as refreshTailwindRuntimeState, g as toCustomAttributesEntities, n as getCompilerContext, t as shouldSkipJsTransform, v as createTailwindRuntimeReadyPromise } from "./precheck-lfenbOTF.mjs";
+import { o as resolveUniUtsPlatform } from "./utils-DsaS975I.mjs";
+import { a as normalizeCssEntries, c as hasConfiguredTailwindV4CssRoots, i as resolveUniAppXOptions, l as upsertTailwindV4CssSource, r as isUniAppXEnabled } from "./tailwindcss-D5RogwtV.mjs";
+import { a as validateCandidatesByGenerator, i as generateCssByGenerator, n as createHmrTimingRecorder, o as mergeMarkedUserLayerComponentsCss, s as processCachedTask, t as createBundleRuntimeClassSetManager } from "./incremental-runtime-class-set-Dt-FUQB5.mjs";
+import { n as createTailwindV3DefaultExtractor, r as isSourceCandidateRequest, t as createSourceCandidateCollector } from "./source-candidates-D7b-Jzsx.mjs";
+import { S as toAbsoluteOutputPath, _ as slash, a as applyLinkedResults, b as normalizeOutputPathKey, c as createBundlerGeneratedCssMarker, d as stripBundlerGeneratedCssMarkers, f as resolvePackageDir, g as isCSSRequest, h as formatPostcssSourceMap, i as createRuntimeAffectingSourceSignature, l as hasBundlerGeneratedCssMarker, m as cleanUrl, n as createBundleBuildState, o as createBundleModuleGraphOptions, p as resolvePluginDisabledState, r as updateBundleBuildState, s as pushConcurrentTaskFactories, t as buildBundleSnapshot, u as parseBundlerGeneratedCssMarkerBlocks, v as isSourceStyleRequest } from "./bundle-state-C-p9eFz1.mjs";
+import { t as logger$1 } from "./logger-BNzxZbZj.mjs";
+import fs, { existsSync, readFileSync } from "node:fs";
+import postcss from "postcss";
+import { splitCandidateTokens } from "tailwindcss-patch";
+import process from "node:process";
+import path from "node:path";
+import { logger } from "@weapp-tailwindcss/logger";
+import { readFile } from "node:fs/promises";
+import { Buffer } from "node:buffer";
+import postcssHtmlTransform from "@weapp-tailwindcss/postcss/html-transform";
+import { parse } from "comment-json";
+import postcssrc from "postcss-load-config";
+//#region src/bundlers/vite/query.ts
+function parseVueRequest(id) {
+	const [filename = id, rawQuery] = id.split(`?`, 2);
+	const searchParams = new URLSearchParams(rawQuery);
+	const query = Object.fromEntries(searchParams);
+	if (query.vue != null) query.vue = true;
+	if (query.index != null) query.index = Number(query.index);
+	if (query.raw != null) query.raw = true;
+	if (query.url != null) query.url = true;
+	if (query.scoped != null) query.scoped = true;
+	const langTypeMatch = [...searchParams.keys()].find((key) => key.startsWith("lang."));
+	const langType = query.lang || (langTypeMatch ? langTypeMatch.slice(5) : void 0);
+	if (langType) query.lang = langType;
+	return {
+		filename,
+		query
+	};
+}
+//#endregion
+//#region src/uni-app-x/style-isolation.ts
+const manifestCache = /* @__PURE__ */ new Map();
+function resolveUniAppXStyleIsolationEnabled(root) {
+	if (!root) return false;
+	const normalizedRoot = path.resolve(root);
+	const cached = manifestCache.get(normalizedRoot);
+	if (cached !== void 0) return cached;
+	const manifestPath = path.join(normalizedRoot, "manifest.json");
+	let enabled = false;
+	try {
+		enabled = `${parse(fs.readFileSync(manifestPath, "utf8"))["uni-app-x"]?.styleIsolationVersion ?? ""}` === "2";
+	} catch {
+		enabled = false;
+	}
+	manifestCache.set(normalizedRoot, enabled);
+	return enabled;
+}
+//#endregion
+//#region src/uni-app-x/vite.ts
+let transformUVuePromise;
+function loadTransformUVue() {
+	transformUVuePromise ?? (transformUVuePromise = import("./transform-FAxHXVZp.mjs").then((mod) => mod.transformUVue));
+	return transformUVuePromise;
+}
+const preprocessorLangs = new Set([
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+]);
+const INLINE_LANG_RE = /lang\.([a-z]+)/i;
+const PREPROCESSOR_EXT_RE = /\.(?:scss|sass|less|styl|stylus)(?:\?|$)/i;
+const UVUE_NVUE_QUERY_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
+const UVUE_NVUE_RE = /\.(?:uvue|nvue)$/;
+function isPreprocessorRequest(id, lang) {
+	const normalizedLang = lang?.toLowerCase();
+	if (normalizedLang && preprocessorLangs.has(normalizedLang)) return true;
+	const inlineLang = id.match(INLINE_LANG_RE)?.[1];
+	if (inlineLang && preprocessorLangs.has(inlineLang.toLowerCase())) return true;
+	return PREPROCESSOR_EXT_RE.test(id);
+}
+function resolveUniAppXCssTarget(id) {
+	return UVUE_NVUE_RE.test(cleanUrl(id)) ? "uvue" : void 0;
+}
+function resolveUniAppXJsTransformEnabled$1(uniAppX) {
+	return uniAppX === void 0 ? true : isUniAppXEnabled(uniAppX);
+}
+function createUniAppXPlugins(options) {
+	const { appType, customAttributesEntities, disabledDefaultTemplateHandler, isIosPlatform: providedIosPlatform, mainCssChunkMatcher, runtimeState, styleHandler, jsHandler, ensureRuntimeClassSet, getResolvedConfig, uniAppX } = options;
+	const resolvedUniAppXOptions = resolveUniAppXOptions(uniAppX);
+	const isIosPlatform = providedIosPlatform ?? resolveUniUtsPlatform().isAppIos;
+	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+	let componentLocalStyleEnabled;
+	function shouldEnableComponentLocalStyle() {
+		if (!resolvedUniAppXOptions.componentLocalStyles.enabled) {
+			componentLocalStyleEnabled = false;
+			return false;
+		}
+		if (!resolvedUniAppXOptions.componentLocalStyles.onlyWhenStyleIsolationVersion2) {
+			componentLocalStyleEnabled = true;
+			return true;
+		}
+		if (componentLocalStyleEnabled !== void 0) return componentLocalStyleEnabled;
+		const root = getResolvedConfig()?.root;
+		componentLocalStyleEnabled = resolveUniAppXStyleIsolationEnabled(root);
+		return componentLocalStyleEnabled;
+	}
+	async function transformStyle(code, id, query) {
+		const parsed = query ?? parseVueRequest(id).query;
+		if (isCSSRequest(id) || parsed.vue && parsed.type === "style") {
+			const cacheKey = `${mainCssChunkMatcher(id, appType) ? "1" : "0"}:${id}`;
+			let styleHandlerOptions = cssHandlerOptionsCache.get(cacheKey);
+			if (!styleHandlerOptions) {
+				styleHandlerOptions = omitUndefined({
+					isMainChunk: mainCssChunkMatcher(id, appType),
+					uniAppXCssTarget: resolveUniAppXCssTarget(id),
+					uniAppXUnsupported: resolvedUniAppXOptions.uvueUnsupported,
+					postcssOptions: { options: {
+						from: id,
+						map: {
+							inline: false,
+							annotation: false,
+							sourcesContent: true
+						}
+					} }
+				});
+				cssHandlerOptionsCache.set(cacheKey, styleHandlerOptions);
+			}
+			const postcssResult = await styleHandler(code, styleHandlerOptions);
+			const warnings = typeof postcssResult.warnings === "function" ? postcssResult.warnings() : [];
+			for (const warning of warnings) logger$1.warn(warning.toString());
+			const postcssMap = await formatPostcssSourceMap(postcssResult.map.toJSON(), cleanUrl(id));
+			return {
+				code: postcssResult.css,
+				map: postcssMap
+			};
+		}
+	}
+	const cssPlugins = [{
+		name: "weapp-tailwindcss:uni-app-x:css",
+		async transform(code, id) {
+			await runtimeState.readyPromise;
+			return transformStyle(code, id);
+		}
+	}, {
+		name: "weapp-tailwindcss:uni-app-x:css:pre",
+		enforce: "pre",
+		async transform(code, id) {
+			await runtimeState.readyPromise;
+			const { query } = parseVueRequest(id);
+			const lang = query.lang;
+			if (isIosPlatform && isPreprocessorRequest(id, lang)) return;
+			return transformStyle(code, id, query);
+		}
+	}];
+	const nvuePlugin = {
+		name: "weapp-tailwindcss:uni-app-x:nvue",
+		enforce: "pre",
+		async buildStart() {
+			await ensureRuntimeClassSet(true);
+		},
+		async transform(code, id) {
+			if (!UVUE_NVUE_QUERY_RE.test(id)) return;
+			const resolvedConfig = getResolvedConfig();
+			const isServeCommand = resolvedConfig?.command === "serve";
+			const isWatchBuild = resolvedConfig?.command === "build" && !!resolvedConfig.build?.watch;
+			const isNonWatchBuild = resolvedConfig?.command === "build" && !resolvedConfig.build?.watch;
+			const currentRuntimeSet = isServeCommand || isWatchBuild || isNonWatchBuild ? await ensureRuntimeClassSet(true) : await ensureRuntimeClassSet();
+			const transformUVue = await loadTransformUVue();
+			const extraOptions = customAttributesEntities.length > 0 || disabledDefaultTemplateHandler ? {
+				customAttributesEntities,
+				disabledDefaultTemplateHandler,
+				enableComponentLocalStyle: shouldEnableComponentLocalStyle()
+			} : void 0;
+			if (extraOptions) return transformUVue(code, id, jsHandler, currentRuntimeSet, extraOptions);
+			if (shouldEnableComponentLocalStyle()) return transformUVue(code, id, jsHandler, currentRuntimeSet, { enableComponentLocalStyle: true });
+			return transformUVue(code, id, jsHandler, currentRuntimeSet);
+		},
+		async handleHotUpdate(ctx) {
+			if (getResolvedConfig()?.command !== "serve") return;
+			if (!UVUE_NVUE_RE.test(ctx.file)) return;
+			await ensureRuntimeClassSet(true);
+		},
+		async watchChange(id) {
+			const resolvedConfig = getResolvedConfig();
+			if (resolvedConfig?.command !== "build" || !resolvedConfig.build?.watch) return;
+			if (!UVUE_NVUE_QUERY_RE.test(id)) return;
+			await ensureRuntimeClassSet(true);
+		}
+	};
+	return [...cssPlugins, nvuePlugin];
+}
+function createUniAppXAssetTask(file, originalSource, outDir, options) {
+	return async () => {
+		const { cache, hashKey, createHandlerOptions, debug, jsHandler, onUpdate, runtimeSet, applyLinkedResults } = options;
+		const absoluteFile = toAbsoluteOutputPath(file, outDir);
+		const rawSource = originalSource.source.toString();
+		await processCachedTask({
+			cache,
+			cacheKey: file,
+			hashKey,
+			rawSource: options.hashSalt ? `${rawSource}\n/*${options.hashSalt}*/` : rawSource,
+			applyResult(source) {
+				originalSource.source = source;
+			},
+			onCacheHit() {
+				debug("js cache hit: %s", file);
+			},
+			async transform() {
+				const currentSource = originalSource.source.toString();
+				const { code, linked } = await jsHandler(currentSource, runtimeSet, createHandlerOptions(absoluteFile, {
+					uniAppX: resolveUniAppXJsTransformEnabled$1(options.uniAppX),
+					babelParserOptions: {
+						plugins: ["typescript"],
+						sourceType: "unambiguous"
+					}
+				}));
+				onUpdate(file, currentSource, code);
+				debug("js handle: %s", file);
+				applyLinkedResults(linked);
+				return { result: code };
+			}
+		});
+	};
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/candidates.ts
+const MUSTACHE_EXPRESSION_RE = /\{\{[\s\S]*?\}\}/g;
+const QUOTED_LITERAL_RE = /'([^']*)'|"([^"]*)"|`([^`]*)`/g;
+const CLASS_ATTRIBUTE_RE = /\bclass\s*=\s*/g;
+const MUSTACHE_OPEN = "{{";
+const MUSTACHE_CLOSE = "}}";
+function isUrlLikeCandidate(candidate) {
+	return candidate.startsWith("//") || candidate.startsWith("http://") || candidate.startsWith("https://");
+}
+function isArbitraryValueCandidate(candidate) {
+	return candidate.includes("[") && candidate.includes("]") && !isUrlLikeCandidate(candidate.trim());
+}
+function collectClassAttributeValues(source) {
+	const values = [];
+	CLASS_ATTRIBUTE_RE.lastIndex = 0;
+	let matched = CLASS_ATTRIBUTE_RE.exec(source);
+	while (matched !== null) {
+		const quoteIndex = CLASS_ATTRIBUTE_RE.lastIndex;
+		const quote = source[quoteIndex];
+		if (quote !== "\"" && quote !== "'") {
+			matched = CLASS_ATTRIBUTE_RE.exec(source);
+			continue;
+		}
+		let expressionDepth = 0;
+		for (let index = quoteIndex + 1; index < source.length; index++) {
+			if (source.startsWith(MUSTACHE_OPEN, index)) {
+				expressionDepth++;
+				index += 1;
+				continue;
+			}
+			if (expressionDepth > 0 && source.startsWith(MUSTACHE_CLOSE, index)) {
+				expressionDepth--;
+				index += 1;
+				continue;
+			}
+			if (expressionDepth === 0 && source[index] === quote) {
+				values.push(source.slice(quoteIndex + 1, index));
+				CLASS_ATTRIBUTE_RE.lastIndex = index + 1;
+				break;
+			}
+		}
+		matched = CLASS_ATTRIBUTE_RE.exec(source);
+	}
+	return values;
+}
+function collectUnescapedDynamicCandidates(source, allowedCandidates) {
+	const matches = /* @__PURE__ */ new Set();
+	const shouldFilterByAllowedCandidates = allowedCandidates !== void 0 && allowedCandidates.size > 0;
+	for (const classValue of collectClassAttributeValues(source)) for (const expression of classValue.match(MUSTACHE_EXPRESSION_RE) ?? []) {
+		QUOTED_LITERAL_RE.lastIndex = 0;
+		let quoted = QUOTED_LITERAL_RE.exec(expression);
+		while (quoted !== null) {
+			const literal = quoted[1] ?? quoted[2] ?? quoted[3] ?? "";
+			for (const candidate of splitCandidateTokens(literal)) {
+				const normalized = candidate.trim();
+				if (!normalized || !isArbitraryValueCandidate(normalized)) continue;
+				if (shouldFilterByAllowedCandidates && !allowedCandidates.has(normalized)) continue;
+				matches.add(normalized);
+			}
+			quoted = QUOTED_LITERAL_RE.exec(expression);
+		}
+	}
+	return [...matches];
+}
+function collectLegacyContainerCompatCandidates(sourceCandidates, candidates) {
+	if (candidates.has("container")) return candidates;
+	if (!sourceCandidates.has("container")) return candidates;
+	return new Set([...candidates, "container"]);
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/css-handler-options.ts
+function createCssHandlerOptionsCache(options) {
+	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+	const cssUserHandlerOptionsCache = /* @__PURE__ */ new Map();
+	const getCssHandlerOptions = (file) => {
+		const majorVersion = options.getMajorVersion();
+		const appType = options.getAppType();
+		const isMainChunk = options.mainCssChunkMatcher(file, appType);
+		const outputRoot = options.getOutputRoot?.();
+		const from = outputRoot ? path.resolve(outputRoot, file) : file;
+		const cacheKey = `${majorVersion ?? "unknown"}:${appType ?? "unknown"}:${isMainChunk ? "1" : "0"}:${outputRoot ?? ""}:${file}`;
+		const cached = cssHandlerOptionsCache.get(cacheKey);
+		if (cached) return cached;
+		const created = {
+			isMainChunk,
+			postcssOptions: { options: { from } },
+			majorVersion,
+			sourceOptions: { outputRoot }
+		};
+		cssHandlerOptionsCache.set(cacheKey, created);
+		return created;
+	};
+	const getCssUserHandlerOptions = (file) => {
+		const majorVersion = options.getMajorVersion();
+		const outputRoot = options.getOutputRoot?.();
+		const cacheKey = `${majorVersion ?? "unknown"}:${outputRoot ?? ""}:${file}`;
+		const cached = cssUserHandlerOptionsCache.get(cacheKey);
+		if (cached) return cached;
+		const created = {
+			...getCssHandlerOptions(file),
+			isMainChunk: false
+		};
+		cssUserHandlerOptionsCache.set(cacheKey, created);
+		return created;
+	};
+	return {
+		getCssHandlerOptions,
+		getCssUserHandlerOptions
+	};
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/css-share-scope.ts
+const CSS_URL_FUNCTION_RE = /url\((?:"([^"]*)"|'([^']*)'|([^)]*))\)/gi;
+const CSS_PATH_INDEPENDENT_URL_RE = /^(?:[a-z][a-z\d+.-]*:|\/\/|\/|#)/i;
+const CSS_IMPORT_RE = /@import\b/i;
+function isPathIndependentCssUrl(value) {
+	const normalized = value.trim();
+	return normalized.length > 0 && CSS_PATH_INDEPENDENT_URL_RE.test(normalized);
+}
+function hasPathDependentCssUrl(rawSource) {
+	CSS_URL_FUNCTION_RE.lastIndex = 0;
+	let match = CSS_URL_FUNCTION_RE.exec(rawSource);
+	while (match !== null) {
+		if (!isPathIndependentCssUrl(match[1] ?? match[2] ?? match[3] ?? "")) return true;
+		match = CSS_URL_FUNCTION_RE.exec(rawSource);
+	}
+	return false;
+}
+function createCssTransformShareScope(file, rawSource) {
+	if (CSS_IMPORT_RE.test(rawSource) || hasPathDependentCssUrl(rawSource)) return `dir:${normalizeOutputPathKey(path.dirname(file))}`;
+	return "global";
+}
+function createCssTransformShareScopeKey(opts, file, rawSource) {
+	if (opts.mainCssChunkMatcher(file, opts.appType)) return `main:${normalizeOutputPathKey(file)}`;
+	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+	if (hasTailwindGeneratedCssMarkers(rawSource) || hasTailwindSourceDirectives(rawSource, { importFallback: generatorOptions.importFallback }) || opts.twPatcher.majorVersion === 3 && (opts.cssEntries?.length ?? 0) > 1 && rawSource.includes("@tailwind")) return `source:${normalizeOutputPathKey(file)}`;
+	return createCssTransformShareScope(file, rawSource);
+}
+function createCssRuntimeSignature(runtimeSignature, generatorCandidateSignature) {
+	return `${runtimeSignature}:${generatorCandidateSignature}`;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/dirty-state.ts
+function hasOmittedKnownBundleFiles(currentBundleFiles, previousBundleFiles) {
+	const currentFileSet = new Set(currentBundleFiles);
+	for (const file of previousBundleFiles) if (!currentFileSet.has(file)) return true;
+	return false;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/js-entries.ts
+function createJsEntryResolver(jsEntries) {
+	const normalizedJsEntries = /* @__PURE__ */ new Map();
+	for (const [id, entry] of jsEntries) normalizedJsEntries.set(normalizeOutputPathKey(id), entry);
+	return (id) => jsEntries.get(id) ?? normalizedJsEntries.get(normalizeOutputPathKey(id));
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/js-handler-options.ts
+function resolveUniAppXJsTransformEnabled(uniAppX) {
+	return uniAppX === void 0 ? true : isUniAppXEnabled(uniAppX);
+}
+function createJsHandlerOptionsFactory(options) {
+	return (absoluteFilename, extra) => ({
+		...extra,
+		filename: absoluteFilename,
+		tailwindcssMajorVersion: options.getMajorVersion(),
+		moduleGraph: options.moduleGraph,
+		babelParserOptions: {
+			...extra?.babelParserOptions ?? {},
+			sourceFilename: absoluteFilename
+		}
+	});
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/js-linking.ts
+function createLinkedUpdateHelpers(options) {
+	const pendingLinkedUpdates = [];
+	const handleLinkedUpdate = (fileName, previous, next) => {
+		options.onUpdate(fileName, previous, next);
+		options.debug("js linked handle: %s", fileName);
+	};
+	const scheduleLinkedApply = (entry, code) => {
+		pendingLinkedUpdates.push(() => {
+			if (entry.output.type === "chunk") entry.output.code = code;
+			else entry.output.source = code;
+		});
+	};
+	const applyLinkedUpdates = (linked) => {
+		applyLinkedResults(linked, options.jsEntries, handleLinkedUpdate, scheduleLinkedApply);
+	};
+	return {
+		applyLinkedUpdates,
+		pendingLinkedUpdates
+	};
+}
+function collectLinkedFileNames(linked, getJsEntry, linkedSet) {
+	if (!linked || !linkedSet) return;
+	for (const id of Object.keys(linked)) {
+		const linkedEntry = getJsEntry(id);
+		if (linkedEntry) linkedSet.add(linkedEntry.fileName);
+	}
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/metrics.ts
+function formatDebugFileList(files, limit = 8) {
+	if (files.size === 0) return "-";
+	const sorted = [...files].sort();
+	if (sorted.length <= limit) return sorted.join(",");
+	return `${sorted.slice(0, limit).join(",")},...(+${sorted.length - limit})`;
+}
+function createEmptyMetric() {
+	return {
+		total: 0,
+		transformed: 0,
+		cacheHits: 0,
+		elapsed: 0
+	};
+}
+function createEmptyMetrics() {
+	return {
+		runtimeSet: 0,
+		html: createEmptyMetric(),
+		js: createEmptyMetric(),
+		css: createEmptyMetric()
+	};
+}
+function measureElapsed(start) {
+	return performance.now() - start;
+}
+function formatCacheHitRate(metric) {
+	if (metric.total === 0) return "0.00%";
+	return `${(metric.cacheHits / metric.total * 100).toFixed(2)}%`;
+}
+function formatMs(value) {
+	return value.toFixed(2);
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/process-plan.ts
+function logBundleProcessPlan(options) {
+	const { debug, snapshot, useIncrementalMode, iteration } = options;
+	const { processFiles } = snapshot;
+	if (useIncrementalMode) {
+		debug("dirty iteration=%d html=%d[%s] js=%d[%s] css=%d[%s] other=%d[%s]", iteration, snapshot.changedByType.html.size, formatDebugFileList(snapshot.changedByType.html), snapshot.changedByType.js.size, formatDebugFileList(snapshot.changedByType.js), snapshot.changedByType.css.size, formatDebugFileList(snapshot.changedByType.css), snapshot.changedByType.other.size, formatDebugFileList(snapshot.changedByType.other));
+		debug("process iteration=%d html=%d[%s] js=%d[%s] css=%d[%s]", iteration, processFiles.html.size, formatDebugFileList(processFiles.html), processFiles.js.size, formatDebugFileList(processFiles.js), processFiles.css.size, formatDebugFileList(processFiles.css));
+		return;
+	}
+	debug("build mode full process html=%d[%s] js=%d[%s] css=%d[%s]", processFiles.html.size, formatDebugFileList(processFiles.html), processFiles.js.size, formatDebugFileList(processFiles.js), processFiles.css.size, formatDebugFileList(processFiles.css));
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/rollup-assets.ts
+function createReplayCssAsset(fileName, source) {
+	return {
+		type: "asset",
+		fileName,
+		name: void 0,
+		source,
+		needsCodeReference: false,
+		names: [],
+		originalFileName: null,
+		originalFileNames: []
+	};
+}
+function isAddWatchFileInvalidRollupPhaseError$1(error) {
+	const candidate = error;
+	return candidate?.code === "INVALID_ROLLUP_PHASE" || candidate?.pluginCode === "INVALID_ROLLUP_PHASE" || candidate?.message?.includes("Cannot call \"addWatchFile\" after the build has finished.") === true;
+}
+function registerGeneratorDependencies$1(ctx, dependencies) {
+	if (typeof ctx.addWatchFile !== "function") return;
+	for (const dependency of dependencies ?? []) try {
+		ctx.addWatchFile(dependency);
+	} catch (error) {
+		if (isAddWatchFileInvalidRollupPhaseError$1(error)) {
+			logger.debug("跳过生成模式依赖监听注册，当前 Rollup 阶段不允许 addWatchFile: %s", dependency);
+			continue;
+		}
+		throw error;
+	}
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/signatures.ts
+function summarizeStringDiff(previous, next) {
+	if (previous === next) return "same";
+	const previousLength = previous.length;
+	const nextLength = next.length;
+	const minLength = Math.min(previousLength, nextLength);
+	let prefixLength = 0;
+	while (prefixLength < minLength && previous.charCodeAt(prefixLength) === next.charCodeAt(prefixLength)) prefixLength += 1;
+	let previousSuffixCursor = previousLength - 1;
+	let nextSuffixCursor = nextLength - 1;
+	while (previousSuffixCursor >= prefixLength && nextSuffixCursor >= prefixLength && previous.charCodeAt(previousSuffixCursor) === next.charCodeAt(nextSuffixCursor)) {
+		previousSuffixCursor -= 1;
+		nextSuffixCursor -= 1;
+	}
+	const previousChangedLength = previousSuffixCursor >= prefixLength ? previousSuffixCursor - prefixLength + 1 : 0;
+	const nextChangedLength = nextSuffixCursor >= prefixLength ? nextSuffixCursor - prefixLength + 1 : 0;
+	return `changed@${prefixLength} old=${previousChangedLength} new=${nextChangedLength} len=${previousLength}->${nextLength}`;
+}
+function createLinkedImpactSignature(entry, linkedImpactsByEntry, sourceHashByFile) {
+	const changedLinkedFiles = linkedImpactsByEntry.get(entry);
+	if (!changedLinkedFiles || changedLinkedFiles.size === 0) return;
+	return [...changedLinkedFiles].sort().map((file) => {
+		return `${file}:${sourceHashByFile.get(file) ?? "missing"}`;
+	}).join(",");
+}
+function createJsHashSalt(runtimeSignature, linkedImpactSignature) {
+	if (!linkedImpactSignature) return runtimeSignature;
+	return `${runtimeSignature}:linked:${linkedImpactSignature}`;
+}
+function createStableTextSignature(input) {
+	let hash = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		hash ^= input.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+function createCandidateSignature(candidates) {
+	if (candidates.size === 0) return "empty";
+	return createStableTextSignature([...candidates].sort().join("\n"));
+}
+function getSnapshotHash(snapshotMap, file, fallback) {
+	return snapshotMap.get(file) ?? fallback;
+}
+function hasRuntimeAffectingSourceChanges(changedByType) {
+	return changedByType.html.size > 0 || changedByType.js.size > 0;
+}
+//#endregion
+//#region src/bundlers/vite/processed-css-assets.ts
+const CSS_OUTPUT_FILE_RE = /\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i;
+function isCssOutputFile(file) {
+	return CSS_OUTPUT_FILE_RE.test(file);
+}
+function getAssetFile(bundleFile, asset) {
+	return asset.fileName || bundleFile;
+}
+function readAssetSource(asset) {
+	return typeof asset.source === "string" ? asset.source : asset.source.toString();
+}
+function appendCss(baseCss, css) {
+	if (baseCss.length === 0) return css;
+	if (css.length === 0) return baseCss;
+	return `${baseCss}\n${css}`;
+}
+function stripStyleExtension(file) {
+	return file.replace(/[?#].*$/, "").replace(/\.(?:css|wxss|acss|ttss|qss|jxss|tyss|scss|sass|less|styl|stylus|pcss|postcss)$/i, "");
+}
+function isAppOriginCssFile$1(file) {
+	return stripStyleExtension(file).split("/").pop() === "app-origin";
+}
+function normalizeMarkerOutputFile(markerFile, resolveViteProcessedCssOutputFile) {
+	return resolveViteProcessedCssOutputFile?.(markerFile) ?? markerFile;
+}
+function isMatchingGeneratedCssMarkerFile(targetFile, markerFile, resolveViteProcessedCssOutputFile) {
+	if (!markerFile) return false;
+	return normalizeOutputPathKey(stripStyleExtension(targetFile)) === normalizeOutputPathKey(stripStyleExtension(normalizeMarkerOutputFile(markerFile, resolveViteProcessedCssOutputFile)));
+}
+function resolveViteProcessedCssAssetSource(file, rawSource, resolveViteProcessedCssOutputFile) {
+	const blocks = parseBundlerGeneratedCssMarkerBlocks(rawSource).filter((block) => block.bundler === "vite");
+	if (blocks.length <= 1) return stripBundlerGeneratedCssMarkers(rawSource);
+	const matchedCss = blocks.filter((block) => isMatchingGeneratedCssMarkerFile(file, block.file, resolveViteProcessedCssOutputFile)).map((block) => block.css);
+	return matchedCss.length > 0 ? matchedCss.join("\n") : stripBundlerGeneratedCssMarkers(rawSource);
+}
+function shouldInjectViteProcessedCssResult(opts, targetFile, sourceFile, options) {
+	if (options.injectIntoMain === true) return true;
+	const targetFileKey = normalizeOutputPathKey(targetFile);
+	const sourceFileKey = normalizeOutputPathKey(sourceFile);
+	const sourceBaseName = sourceFileKey.replace(/\.(?:css|wxss|acss|ttss|qss|jxss|tyss)$/i, "").split("/").pop();
+	return sourceFileKey !== targetFileKey && (opts.mainCssChunkMatcher(sourceFile, opts.appType) || sourceBaseName === "app" || sourceBaseName === "main");
+}
+function collectViteProcessedCssAssetResults(bundle, options) {
+	let collected = 0;
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = getAssetFile(bundleFile, output);
+		if (!isCssOutputFile(file) || !options.isViteProcessedCssAsset?.(output, file)) continue;
+		const rawSource = readAssetSource(output);
+		const nextCss = resolveViteProcessedCssAssetSource(file, rawSource, options.resolveViteProcessedCssOutputFile);
+		if (nextCss !== rawSource) output.source = nextCss;
+		options.markCssAssetProcessed?.(output, file);
+		options.recordCssAssetResult?.(file, nextCss);
+		const resolvedOutputFile = options.resolveViteProcessedCssOutputFile?.(file) ?? file;
+		const shouldReplayIntoMainCss = options.opts != null && (normalizeOutputPathKey(resolvedOutputFile) !== normalizeOutputPathKey(file) && options.opts.mainCssChunkMatcher(resolvedOutputFile, options.opts.appType) || isAppOriginCssFile$1(file));
+		options.recordViteProcessedCssAssetResult?.(file, nextCss, { injectIntoMain: shouldReplayIntoMainCss || void 0 });
+		options.debug?.("collect vite-processed css asset: %s bytes=%d", file, nextCss.length);
+		collected++;
+	}
+	return collected;
+}
+function injectViteProcessedCssIntoMainCssAssets(bundle, options) {
+	const viteCssResults = [...options.getViteProcessedCssAssetResults?.() ?? []].map(([file, record]) => {
+		return typeof record === "string" ? {
+			file,
+			css: record,
+			injectIntoMain: void 0
+		} : {
+			file,
+			css: record.css,
+			injectIntoMain: record.injectIntoMain
+		};
+	}).filter((record) => record.css.length > 0);
+	if (viteCssResults.length === 0) return 0;
+	let injected = 0;
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = getAssetFile(bundleFile, output);
+		if (!options.opts.cssMatcher(file) || !options.opts.mainCssChunkMatcher(file, options.opts.appType)) continue;
+		const mainFileKey = normalizeOutputPathKey(file);
+		const originalSource = readAssetSource(output);
+		let nextCss = originalSource;
+		for (const record of viteCssResults) {
+			if (!shouldInjectViteProcessedCssResult(options.opts, mainFileKey, record.file, record)) continue;
+			const css = stripBundlerGeneratedCssMarkers(record.css).trim();
+			if (css.length === 0) continue;
+			const mergedLayerCss = mergeMarkedUserLayerComponentsCss(nextCss, css);
+			if (mergedLayerCss.merged) {
+				nextCss = mergedLayerCss.css;
+				continue;
+			}
+			if (nextCss.includes(css)) continue;
+			nextCss = appendCss(nextCss, css);
+		}
+		if (nextCss === originalSource) continue;
+		output.source = nextCss;
+		options.markCssAssetProcessed?.(output, file);
+		options.recordCssAssetResult?.(file, nextCss);
+		options.onUpdate?.(file, originalSource, nextCss);
+		options.debug?.("inject vite-processed css into main css asset: %s bytes=%d", file, nextCss.length);
+		injected++;
+	}
+	return injected;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle.ts
+function addSiblingCssFile(files, file) {
+	if (file.endsWith(".wxml")) files.add(file.replace(/\.wxml$/, ".wxss"));
+	else if (file.endsWith(".js")) files.add(file.replace(/\.js$/, ".wxss"));
+}
+function collectRuntimeLinkedCssFiles(snapshot) {
+	const files = /* @__PURE__ */ new Set();
+	for (const file of snapshot.runtimeAffectingChangedByType.html) addSiblingCssFile(files, file);
+	for (const file of snapshot.runtimeAffectingChangedByType.js) addSiblingCssFile(files, file);
+	return files;
+}
+function resolveReplayCssOutputFile(rootDir, file) {
+	const normalizedFile = normalizeOutputPathKey(path.isAbsolute(file) ? path.relative(rootDir, file) : file);
+	if (normalizedFile.length === 0 || normalizedFile === "." || normalizedFile === ".." || normalizedFile.startsWith("../")) return normalizeOutputPathKey(path.basename(file));
+	return normalizedFile;
+}
+const SOURCE_STYLE_OUTPUT_EXT_RE = /\.(?:less|sass|scss|styl|stylus|pcss|postcss)$/i;
+const CSS_SOURCE_OUTPUT_EXT_RE = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)$/i;
+const MINI_PROGRAM_STYLE_OUTPUT_EXT_RE = /\.(?:wx|ac|jx|tt|q|ty)ss$/i;
+const SOURCE_STYLE_NON_CSS_SYNTAX_RE = /(?:^|\n)\s*(?:\/\/|\$[\w-]+\s*:|@(?:use|forward|mixin|include|function)\b)/;
+function resolveViteCssOutputFile(file, opts, isWebGeneratorTarget) {
+	if (isWebGeneratorTarget || opts.cssMatcher(file) || !SOURCE_STYLE_OUTPUT_EXT_RE.test(file) || !isCSSRequest(file)) return file;
+	return file.replace(SOURCE_STYLE_OUTPUT_EXT_RE, ".wxss");
+}
+function resolveViteCssPipelineOutputFile(file, _opts, rootDir, isWebGeneratorTarget = false) {
+	const normalizedFile = resolveReplayCssOutputFile(rootDir, file);
+	if (isWebGeneratorTarget || MINI_PROGRAM_STYLE_OUTPUT_EXT_RE.test(normalizedFile) || !CSS_SOURCE_OUTPUT_EXT_RE.test(normalizedFile) || !isCSSRequest(normalizedFile)) return normalizedFile;
+	return normalizedFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, ".wxss");
+}
+function canProcessViteSourceStyleAsCss(source, file) {
+	if (SOURCE_STYLE_NON_CSS_SYNTAX_RE.test(source)) return false;
+	try {
+		postcss.parse(source, { from: file });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isPackageJsonImportRequest(request) {
+	return request.startsWith("#");
+}
+function normalizeMatchedCssSourcePath(file) {
+	if (!file || !path.isAbsolute(file)) return;
+	return path.resolve(file.replace(/[?#].*$/, ""));
+}
+function stripStyleFileExtension(file) {
+	const normalized = file.replace(/[?#].*$/, "");
+	const ext = path.extname(normalized);
+	return ext ? normalized.slice(0, -ext.length) : normalized;
+}
+function isAppOriginCssFile(file) {
+	return path.basename(stripStyleFileExtension(file)) === "app-origin";
+}
+function normalizeCssSourceForCompare(css) {
+	return css.trim();
+}
+async function createScopedGeneratorCandidateSignature(rawSource, sourceFile, fallbackSignature, getSourceCandidatesForEntries, options = {}) {
+	if (!getSourceCandidatesForEntries || !rawSource.includes("@source")) return fallbackSignature;
+	const resolved = await resolveTailwindV4EntriesFromCssCached(rawSource, path.dirname(path.resolve(sourceFile.replace(/[?#].*$/, ""))));
+	if (resolved?.entries === void 0) return fallbackSignature;
+	const scopedSignature = createCandidateSignature(getSourceCandidatesForEntries(resolved.entries));
+	return options.includeFallbackSignature === true ? `${scopedSignature}:${fallbackSignature}` : scopedSignature;
+}
+function isMatchingCssSourceFile(outputFile, cssSourceFile, outputRoot) {
+	return stripStyleFileExtension(path.resolve(outputRoot, outputFile)) === stripStyleFileExtension(path.resolve(cssSourceFile));
+}
+function collectStyleFileMatchBases(file, roots) {
+	const normalizedFile = file.replace(/[?#].*$/, "");
+	const bases = /* @__PURE__ */ new Set();
+	const addBase = (candidate) => {
+		const base = slash(stripStyleFileExtension(candidate));
+		if (base.length > 0) bases.add(base);
+	};
+	addBase(normalizedFile);
+	const resolvedRoots = roots.filter((root) => typeof root === "string" && root.length > 0).map((root) => path.resolve(root));
+	if (path.isAbsolute(normalizedFile)) for (const root of resolvedRoots) {
+		const relative = path.relative(root, normalizedFile);
+		if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) addBase(relative);
+	}
+	else for (const root of resolvedRoots) addBase(path.resolve(root, normalizedFile));
+	return bases;
+}
+function collectParentDirectories(file) {
+	const directories = [];
+	let current = path.dirname(path.resolve(file.replace(/[?#].*$/, "")));
+	while (true) {
+		directories.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return directories;
+}
+function hasMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	const outputBases = collectStyleFileMatchBases(outputFile, [outputRoot]);
+	const sourceBases = collectStyleFileMatchBases(sourceFile, [sourceRoot, ...collectParentDirectories(sourceFile)]);
+	for (const outputBase of outputBases) for (const sourceBase of sourceBases) if (outputBase === sourceBase || outputBase.endsWith(`/${sourceBase}`) || sourceBase.endsWith(`/${outputBase}`)) return true;
+	return false;
+}
+function collectConfiguredTailwindV4CssSources(opts) {
+	const patcherCssSources = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssSources ?? [];
+	return [...opts.tailwindcss?.v4?.cssSources ?? [], ...patcherCssSources ?? []];
+}
+function collectConfiguredCssEntries(opts) {
+	const patcherCssEntries = opts.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssEntries ?? [];
+	return [
+		...opts.cssEntries ?? [],
+		...opts.tailwindcss?.v4?.cssEntries ?? [],
+		...patcherCssEntries ?? []
+	].filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+function collectCssConfigBaseCandidates(source, file, outputRoot, opts) {
+	const candidates = [];
+	const seen = /* @__PURE__ */ new Set();
+	const addCandidate = (candidate) => {
+		if (!candidate) return;
+		const normalized = path.resolve(candidate);
+		if (seen.has(normalized)) return;
+		seen.add(normalized);
+		candidates.push(normalized);
+	};
+	addCandidate(path.dirname(path.resolve(outputRoot, file.replace(/[?#].*$/, ""))));
+	const normalizedSource = normalizeCssSourceForCompare(source);
+	const patcherProjectRoot = typeof opts.tailwindcssPatcherOptions?.projectRoot === "string" ? opts.tailwindcssPatcherOptions.projectRoot : void 0;
+	const sourceBaseFallback = opts.tailwindcss?.v4?.base ?? patcherProjectRoot ?? opts.tailwindcssBasedir ?? outputRoot;
+	const sourceRoot = opts.tailwindcssBasedir ?? patcherProjectRoot;
+	const configuredCssEntries = collectConfiguredCssEntries(opts);
+	for (const cssEntry of configuredCssEntries) {
+		const resolvedCssEntry = path.resolve(cssEntry);
+		if (configuredCssEntries.length === 1 || isMatchingCssSourceFile(file, resolvedCssEntry, outputRoot) || hasMatchingStyleFileBase(file, resolvedCssEntry, outputRoot, sourceRoot)) addCandidate(path.dirname(resolvedCssEntry));
+	}
+	for (const cssSource of collectConfiguredTailwindV4CssSources(opts)) {
+		const cssSourceFile = normalizeMatchedCssSourcePath(cssSource.file);
+		const cssSourceCss = typeof cssSource.css === "string" ? normalizeCssSourceForCompare(cssSource.css) : void 0;
+		if (cssSourceFile && !isMatchingCssSourceFile(file, cssSourceFile, outputRoot) && cssSourceCss !== normalizedSource) continue;
+		addCandidate(cssSourceFile ? path.dirname(cssSourceFile) : void 0);
+		addCandidate(resolveTailwindV4CssSourceBase(cssSource, sourceBaseFallback));
+	}
+	return candidates;
+}
+function normalizeRelativeCssConfigDirectives(source, file, outputRoot, opts) {
+	if (!source.includes("@config")) return source;
+	const baseCandidates = collectCssConfigBaseCandidates(source, file, outputRoot, opts);
+	return source.replace(/@config\s+(["'])(.+?)\1\s*;?/g, (full, quote, request) => {
+		if (path.isAbsolute(request) || isPackageJsonImportRequest(request)) return full;
+		for (const base of baseCandidates) {
+			const configFile = path.resolve(base, request);
+			if (existsSync(configFile)) return `@config ${quote}${slash(configFile)}${quote};`;
+		}
+		return full;
+	});
+}
+function createGenerateBundleHook(context) {
+	const state = createBundleBuildState();
+	const lastCssResultByFile = /* @__PURE__ */ new Map();
+	let currentOutDir;
+	const cssHandlerOptions = createCssHandlerOptionsCache({
+		getAppType: () => context.opts.appType,
+		mainCssChunkMatcher: context.opts.mainCssChunkMatcher,
+		getMajorVersion: () => context.runtimeState.twPatcher.majorVersion,
+		getOutputRoot: () => currentOutDir
+	});
+	return async function generateBundle(_opt, bundle) {
+		const addWatchFile = (id) => this.addWatchFile?.(id);
+		const { opts, runtimeState, ensureBundleRuntimeClassSet, debug, getResolvedConfig, markCssAssetProcessed, isCssAssetProcessed, isViteProcessedCssAsset, recordCssAssetResult, recordViteProcessedCssAssetResult, getViteProcessedCssAssetResults, getViteProcessedCssAssetResult, getSourceCandidates, getSourceCandidatesForEntries, waitForSourceCandidateSyncs, rememberCssSource, getRememberedCssSources, getRememberedCssSignature, setRememberedCssSignature, recordGeneratorCandidates, hmrTimingRecorder } = context;
+		const { cache, onEnd, onStart, onUpdate, styleHandler, templateHandler, jsHandler, uniAppX } = opts;
+		const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+		const isWebGeneratorTarget = generatorOptions.target === "web";
+		const shouldGenerateWebCssByGenerator = isWebGeneratorTarget && runtimeState.twPatcher.majorVersion === 3;
+		const { getCssHandlerOptions, getCssUserHandlerOptions } = cssHandlerOptions;
+		const resolvedConfig = getResolvedConfig();
+		const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process.cwd();
+		const outDir = resolvedConfig?.build?.outDir ? path.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
+		await runtimeState.readyPromise;
+		debug("start");
+		onStart();
+		collectViteProcessedCssAssetResults(bundle, {
+			opts,
+			isViteProcessedCssAsset,
+			markCssAssetProcessed,
+			recordCssAssetResult,
+			recordViteProcessedCssAssetResult,
+			resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget),
+			debug
+		});
+		const hmrTimingStartedAt = performance.now();
+		const timingDetails = {};
+		const recordTimingDetail = (name, startedAt) => {
+			timingDetails[name] = (timingDetails[name] ?? 0) + Math.max(0, performance.now() - startedAt);
+		};
+		const timeTask = async (name, task) => {
+			const start = performance.now();
+			try {
+				await task();
+			} finally {
+				recordTimingDetail(`tasks.${name}`, start);
+			}
+		};
+		const metrics = createEmptyMetrics();
+		const forceRuntimeRefreshByEnv = process.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1";
+		const disableDirtyOptimization = process.env["WEAPP_TW_VITE_DISABLE_DIRTY"] === "1";
+		const disableJsPrecheck = process.env["WEAPP_TW_VITE_DISABLE_JS_PRECHECK"] === "1";
+		const debugCssDiff = process.env["WEAPP_TW_VITE_DEBUG_CSS_DIFF"] === "1";
+		const disableV3OxideSourceRuntime = process.env["WEAPP_TW_VITE_DISABLE_V3_OXIDE_RUNTIME"] === "1";
+		const bundleFiles = Object.keys(bundle);
+		const buildCommand = resolvedConfig?.command === "build";
+		const hasPreviousBundleState = state.iteration > 0 || state.sourceHashByFile.size > 0;
+		const hasOmittedKnownFiles = hasOmittedKnownBundleFiles(bundleFiles, state.sourceHashByFile.keys());
+		const useIncrementalMode = !buildCommand || hasPreviousBundleState || hasOmittedKnownFiles;
+		currentOutDir = outDir;
+		const snapshotStart = performance.now();
+		const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization || !useIncrementalMode, { hasOmittedKnownFiles });
+		recordTimingDetail("snapshot", snapshotStart);
+		const useBundleRuntimeClassSet = !isWebGeneratorTarget && (useIncrementalMode || runtimeState.twPatcher.majorVersion === 4);
+		const forceRuntimeRefreshBySource = useIncrementalMode && hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
+		const processFiles = snapshot.processFiles;
+		logBundleProcessPlan({
+			debug,
+			snapshot,
+			useIncrementalMode,
+			iteration: state.iteration + 1
+		});
+		const sourceCandidateWaitStart = performance.now();
+		await waitForSourceCandidateSyncs?.();
+		recordTimingDetail("sourceCandidates.wait", sourceCandidateWaitStart);
+		const sourceCandidates = getSourceCandidates?.() ?? /* @__PURE__ */ new Set();
+		const jsEntries = snapshot.jsEntries;
+		const getJsEntry = createJsEntryResolver(jsEntries);
+		const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
+		const hasCssAssetEntry = snapshot.entries.some((entry) => entry.type === "css" && entry.output.type === "asset");
+		const hasRuntimeAffectingChanges = hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
+		const useV3OxideSourceRuntime = runtimeState.twPatcher.majorVersion === 3 && sourceCandidates.size > 0 && hasCssAssetEntry && !forceRuntimeRefreshByEnv && !disableV3OxideSourceRuntime;
+		const runtimeStart = performance.now();
+		const transformBaseRuntime = useV3OxideSourceRuntime ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv, { transformOnly: true }) : void 0;
+		const runtime = isWebGeneratorTarget && !shouldGenerateWebCssByGenerator ? /* @__PURE__ */ new Set() : useV3OxideSourceRuntime ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv, {
+			allowBaselineOnlyInitialSync: true,
+			baseClassSet: sourceCandidates
+		}) : useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv, { allowBaselineOnlyInitialSync: buildCommand }) : await context.ensureRuntimeClassSet(forceRuntimeRefreshByEnv);
+		if (useV3OxideSourceRuntime) debug("[tailwindcss:v3] use oxide source candidates as runtime input, candidates=%d", sourceCandidates.size);
+		const shouldFilterTailwindV4MiniProgramCandidates = runtimeState.twPatcher.majorVersion === 4 && generatorOptions.target === "weapp";
+		const collectedGeneratorCandidates = new Set([...runtime, ...sourceCandidates]);
+		const filteredGeneratorCandidates = shouldFilterTailwindV4MiniProgramCandidates ? filterUnsupportedMiniProgramTailwindV4Candidates(collectedGeneratorCandidates) : collectedGeneratorCandidates;
+		let transformRuntime = transformBaseRuntime ?? runtime;
+		let generatorRuntime = collectLegacyContainerCompatCandidates(sourceCandidates, runtimeState.twPatcher.majorVersion === 3 && hasRuntimeAffectingChanges && transformBaseRuntime ? new Set([...filteredGeneratorCandidates, ...transformBaseRuntime]) : filteredGeneratorCandidates);
+		const cssEntries = snapshot.entries.filter((entry) => entry.type === "css" && entry.output.type === "asset");
+		if (runtimeState.twPatcher.majorVersion === 3 && useV3OxideSourceRuntime && generatorRuntime.size > 0 && (state.iteration === 0 || !hasRuntimeAffectingChanges) && cssEntries.length <= 1) {
+			const mainCssEntry = cssEntries.find((entry) => getCssHandlerOptions(entry.file).isMainChunk) ?? cssEntries[0];
+			if (mainCssEntry) {
+				const validatedRuntime = await validateCandidatesByGenerator({
+					opts,
+					runtimeState,
+					candidates: generatorRuntime,
+					rawSource: mainCssEntry.source,
+					file: mainCssEntry.file,
+					cssHandlerOptions: getCssHandlerOptions(mainCssEntry.file),
+					cssUserHandlerOptions: getCssUserHandlerOptions(mainCssEntry.file),
+					styleHandler,
+					debug
+				});
+				if (validatedRuntime.size > 0) {
+					generatorRuntime = collectLegacyContainerCompatCandidates(sourceCandidates, validatedRuntime);
+					transformRuntime = generatorRuntime;
+				} else {
+					generatorRuntime = validatedRuntime;
+					transformRuntime = validatedRuntime;
+				}
+			}
+		}
+		const generatorCandidateSignature = createCandidateSignature(generatorRuntime);
+		const generatorCandidatesChanged = state.generatorCandidateSignature !== generatorCandidateSignature;
+		const runtimeLinkedCssFiles = collectRuntimeLinkedCssFiles(snapshot);
+		recordGeneratorCandidates?.(generatorRuntime);
+		const dynamicRetryCandidates = new Set([
+			...sourceCandidates,
+			...generatorRuntime,
+			...transformRuntime
+		]);
+		const defaultTemplateHandlerOptions = { runtimeSet: transformRuntime };
+		metrics.runtimeSet = measureElapsed(runtimeStart);
+		timingDetails["runtime"] = metrics.runtimeSet;
+		if (forceRuntimeRefreshBySource) debug("runtimeSet forced refresh due to source changes: html=%d js=%d", snapshot.runtimeAffectingChangedByType.html.size, snapshot.runtimeAffectingChangedByType.js.size);
+		debug("get runtimeSet, class count: %d, transform class count: %d", runtime.size, transformRuntime.size);
+		const runtimeSignature = getRuntimeClassSetSignature(runtimeState.twPatcher) ?? "runtime:missing";
+		const shouldProcessTailwindGeneration = !useIncrementalMode || hasRuntimeAffectingChanges || generatorCandidatesChanged || snapshot.processFiles.css.size > 0;
+		const { applyLinkedUpdates, pendingLinkedUpdates } = createLinkedUpdateHelpers({
+			jsEntries,
+			onUpdate,
+			debug
+		});
+		const createHandlerOptions = createJsHandlerOptionsFactory({
+			getMajorVersion: () => runtimeState.twPatcher.majorVersion,
+			moduleGraph: moduleGraphOptions
+		});
+		const linkedByEntry = useIncrementalMode ? /* @__PURE__ */ new Map() : void 0;
+		const sharedCssResultCache = /* @__PURE__ */ new Map();
+		const tasks = [];
+		const jsTaskFactories = [];
+		for (const entry of snapshot.entries) {
+			const { file, output: originalSource, source: originalEntrySource, type } = entry;
+			if (type === "html" && originalSource.type === "asset") {
+				metrics.html.total++;
+				if (isWebGeneratorTarget) {
+					debug("html skip web target: %s", file);
+					continue;
+				}
+				if (!processFiles.html.has(file)) continue;
+				const rawSource = originalEntrySource;
+				tasks.push(timeTask("html", () => processCachedTask({
+					cache,
+					cacheKey: file,
+					hashKey: `${file}:html:${runtimeSignature}`,
+					hash: getSnapshotHash(snapshot.sourceHashByFile, file, rawSource),
+					applyResult(source) {
+						originalSource.source = source;
+					},
+					onCacheHit() {
+						metrics.html.cacheHits++;
+						debug("html cache hit: %s", file);
+					},
+					async transform() {
+						const start = performance.now();
+						let transformed = await templateHandler(rawSource, defaultTemplateHandlerOptions);
+						let unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed);
+						let retryRuntimeSet;
+						if (unresolvedDynamicCandidates.length > 0) {
+							const fullRuntimeSet = await context.ensureRuntimeClassSet(true);
+							const allowedRetryCandidates = fullRuntimeSet.size === 0 ? unresolvedDynamicCandidates : unresolvedDynamicCandidates.filter((candidate) => dynamicRetryCandidates.has(candidate) || fullRuntimeSet.has(candidate));
+							retryRuntimeSet = new Set([...fullRuntimeSet, ...allowedRetryCandidates]);
+							unresolvedDynamicCandidates = unresolvedDynamicCandidates.filter((candidate) => retryRuntimeSet?.has(candidate) === true);
+						}
+						if (retryRuntimeSet && unresolvedDynamicCandidates.length > 0) {
+							logger.warn("检测到已提取 WXML 动态类名未完成转译，已回退到完整 runtimeSet 重试: %s -> %O", file, unresolvedDynamicCandidates);
+							transformed = await templateHandler(rawSource, { runtimeSet: retryRuntimeSet });
+							unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed, retryRuntimeSet);
+							if (unresolvedDynamicCandidates.length > 0) logger.warn("已提取 WXML 动态类名在完整 runtimeSet 重试后仍未完成转译: %s -> %O", file, unresolvedDynamicCandidates);
+						}
+						metrics.html.elapsed += measureElapsed(start);
+						metrics.html.transformed++;
+						onUpdate(file, rawSource, transformed);
+						debug("html handle: %s", file);
+						return { result: transformed };
+					}
+				})));
+				continue;
+			}
+			if (type === "css" && originalSource.type === "asset") {
+				metrics.css.total++;
+				const rawSource = normalizeRelativeCssConfigDirectives(originalEntrySource, file, outDir, opts);
+				const outputFile = resolveViteCssOutputFile(file, opts, isWebGeneratorTarget);
+				if (outputFile !== file && !canProcessViteSourceStyleAsCss(rawSource, file)) {
+					delete bundle[file];
+					debug("css skip raw source style asset: %s -> %s", file, outputFile);
+					continue;
+				}
+				const applyCssResult = (source) => {
+					if (outputFile !== file) {
+						delete bundle[file];
+						if (typeof this.emitFile === "function") this.emitFile({
+							type: "asset",
+							fileName: outputFile,
+							source
+						});
+						else bundle[outputFile] = createReplayCssAsset(outputFile, source);
+						originalSource.fileName = outputFile;
+					}
+					originalSource.source = source;
+				};
+				if (isWebGeneratorTarget && !shouldGenerateWebCssByGenerator) {
+					applyCssResult(rawSource);
+					markCssAssetProcessed?.(originalSource, outputFile);
+					onUpdate(outputFile, rawSource, rawSource);
+					debug("css skip web target: %s", outputFile);
+					continue;
+				}
+				const hasViteProcessedCssRecord = getViteProcessedCssAssetResult?.(file) != null;
+				const viteProcessedCssAsset = isViteProcessedCssAsset?.(originalSource, file) === true || hasViteProcessedCssRecord;
+				const cssAssetProcessed = isCssAssetProcessed?.(originalSource, file) === true;
+				const alreadyProcessedCssAsset = viteProcessedCssAsset || cssAssetProcessed;
+				const rememberedCssSource = viteProcessedCssAsset && getRememberedCssSources != null ? [...getRememberedCssSources()].map(([, remembered]) => remembered).find((remembered) => {
+					const originalFiles = [
+						file,
+						originalSource.originalFileName,
+						...originalSource.originalFileNames ?? []
+					].filter((item) => typeof item === "string" && item.length > 0);
+					return normalizeOutputPathKey(remembered.outputFile) === normalizeOutputPathKey(outputFile) || originalFiles.some((originalFile) => normalizeOutputPathKey(remembered.sourceFile) === normalizeOutputPathKey(originalFile));
+				}) : void 0;
+				const generatorRawSource = viteProcessedCssAsset ? rememberedCssSource?.rawSource ?? rawSource : rawSource;
+				const generatorSourceFile = viteProcessedCssAsset ? rememberedCssSource?.sourceFile ?? file : file;
+				const outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+				const cssHandlerOptions = viteProcessedCssAsset ? {
+					...getCssHandlerOptions(generatorSourceFile),
+					isMainChunk: outputCssHandlerOptions.isMainChunk || isAppOriginCssFile(file)
+				} : getCssHandlerOptions(file);
+				const generatorCssUserHandlerOptions = getCssUserHandlerOptions(generatorSourceFile);
+				const cssRuntimeAffectingSignature = snapshot.runtimeAffectingSignatureByFile.get(file) ?? createRuntimeAffectingSourceSignature(generatorRawSource, "css");
+				const cssRuntimeAffectingHash = snapshot.runtimeAffectingHashByFile.get(file) ?? cache.computeHash(cssRuntimeAffectingSignature);
+				const cssShareScope = createCssTransformShareScopeKey(opts, generatorSourceFile, generatorRawSource);
+				const shouldRegenerateAppOriginCss = viteProcessedCssAsset && isAppOriginCssFile(file);
+				const shouldTrackGeneratorRuntime = shouldProcessTailwindGeneration && (!useIncrementalMode || cssHandlerOptions.isMainChunk || processFiles.css.has(file) || runtimeLinkedCssFiles.has(file) || shouldRegenerateAppOriginCss);
+				const canRegenerateProcessedMainCss = cssHandlerOptions.isMainChunk && (getViteProcessedCssAssetResult?.(file)?.injectIntoMain === true || shouldRegenerateAppOriginCss);
+				if (alreadyProcessedCssAsset && (!shouldTrackGeneratorRuntime || !canRegenerateProcessedMainCss)) {
+					const nextCss = stripBundlerGeneratedCssMarkers(rawSource);
+					applyCssResult(nextCss);
+					markCssAssetProcessed?.(originalSource, outputFile);
+					recordCssAssetResult?.(outputFile, nextCss);
+					onUpdate(outputFile, rawSource, nextCss);
+					debug("css skip vite-processed asset: %s", outputFile);
+					continue;
+				}
+				const trackedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? generatorCandidateSignature : "generator:stable";
+				const scopedGeneratorCandidateSignature = shouldTrackGeneratorRuntime ? await createScopedGeneratorCandidateSignature(generatorRawSource, generatorSourceFile, trackedGeneratorCandidateSignature, getSourceCandidatesForEntries, { includeFallbackSignature: cssHandlerOptions.isMainChunk }) : trackedGeneratorCandidateSignature;
+				const cssRuntimeSignature = createCssRuntimeSignature(runtimeSignature, scopedGeneratorCandidateSignature);
+				const cssSharedCacheKey = `${cssShareScope}:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${cssHandlerOptions.isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}`;
+				if (!shouldTrackGeneratorRuntime) {
+					const lastCss = lastCssResultByFile.get(outputFile) ?? lastCssResultByFile.get(file);
+					if (lastCss != null) {
+						applyCssResult(lastCss);
+						markCssAssetProcessed?.(originalSource, outputFile);
+						metrics.css.cacheHits++;
+						debug("css replay last result: %s", outputFile);
+						continue;
+					}
+				}
+				tasks.push(timeTask("css", () => processCachedTask({
+					cache,
+					cacheKey: file,
+					hashKey: `${file}:css:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`,
+					hash: `${getSnapshotHash(snapshot.runtimeAffectingHashByFile, file, cssRuntimeAffectingHash)}:${scopedGeneratorCandidateSignature}`,
+					applyResult(source) {
+						applyCssResult(source);
+						lastCssResultByFile.set(outputFile, source);
+						markCssAssetProcessed?.(originalSource, outputFile);
+						rememberCssSource?.({
+							outputFile,
+							rawSource: generatorRawSource,
+							sourceFile: generatorSourceFile
+						}, cssRuntimeSignature);
+					},
+					onCacheHit() {
+						metrics.css.cacheHits++;
+						debug("css cache hit: %s", file);
+					},
+					async transform() {
+						if (cssSharedCacheKey) {
+							const sharedCssTask = sharedCssResultCache.get(cssSharedCacheKey);
+							if (sharedCssTask != null) {
+								metrics.css.cacheHits++;
+								debug("css shared hit: %s", file);
+								const sharedCss = await sharedCssTask;
+								onUpdate(file, rawSource, sharedCss);
+								return { result: sharedCss };
+							}
+						}
+						const runTransform = async () => {
+							const start = performance.now();
+							await runtimeState.readyPromise;
+							const previousCss = useIncrementalMode && !hasRuntimeAffectingChanges && !snapshot.changedByType.css.has(file) ? lastCssResultByFile.get(outputFile) ?? lastCssResultByFile.get(file) : void 0;
+							const generated = await generateCssByGenerator({
+								opts,
+								runtimeState,
+								runtime: generatorRuntime,
+								rawSource: generatorRawSource,
+								file: generatorSourceFile,
+								cssHandlerOptions,
+								cssUserHandlerOptions: generatorCssUserHandlerOptions,
+								getSourceCandidatesForEntries,
+								styleHandler,
+								debug,
+								previousCss
+							});
+							if (generated) {
+								registerGeneratorDependencies$1({ addWatchFile }, generated.dependencies);
+								if (debugCssDiff) debug("css diff %s: %s", generatorSourceFile, summarizeStringDiff(generatorRawSource, generated.css));
+								debug("css generated result: %s bytes=%d", file, generated.css.length);
+								recordCssAssetResult?.(outputFile, generated.css);
+								if (viteProcessedCssAsset && cssHandlerOptions.isMainChunk) recordViteProcessedCssAssetResult?.(file, generated.css, { injectIntoMain: true });
+								metrics.css.elapsed += measureElapsed(start);
+								metrics.css.transformed++;
+								debug("css handle via tailwind v%s engine(%s): %s", runtimeState.twPatcher.majorVersion, generated.target, outputFile);
+								return generated.css;
+							}
+							if (isWebGeneratorTarget) {
+								metrics.css.elapsed += measureElapsed(start);
+								metrics.css.transformed++;
+								debug("css preserve web target: %s", outputFile);
+								return rawSource;
+							}
+							const { css } = await styleHandler(rawSource, getCssHandlerOptions(file));
+							if (debugCssDiff) debug("css diff %s: %s", file, summarizeStringDiff(rawSource, css));
+							metrics.css.elapsed += measureElapsed(start);
+							metrics.css.transformed++;
+							return css;
+						};
+						const cssTask = cssSharedCacheKey ? sharedCssResultCache.get(cssSharedCacheKey) ?? runTransform() : runTransform();
+						if (cssSharedCacheKey && !sharedCssResultCache.has(cssSharedCacheKey)) sharedCssResultCache.set(cssSharedCacheKey, cssTask);
+						const css = await cssTask;
+						onUpdate(outputFile, rawSource, css);
+						debug("css handle: %s", outputFile);
+						return { result: css };
+					}
+				})));
+				continue;
+			}
+			if (type !== "js") continue;
+			metrics.js.total++;
+			if (isWebGeneratorTarget) {
+				debug("js skip web target: %s", file);
+				continue;
+			}
+			const shouldTransformJs = !useIncrementalMode || processFiles.js.has(file);
+			if (!shouldTransformJs) debug("js skip transform (clean), replay cache: %s", file);
+			if (originalSource.type === "chunk") {
+				const absoluteFile = path.resolve(outDir, file);
+				const initialRawSource = originalEntrySource;
+				const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
+				if (linkedByEntry && linkedSet) linkedByEntry.set(file, linkedSet);
+				jsTaskFactories.push(async () => {
+					await timeTask("js", async () => {
+						const hashSalt = createJsHashSalt(runtimeSignature, useIncrementalMode ? createLinkedImpactSignature(file, snapshot.linkedImpactsByEntry, snapshot.sourceHashByFile) : void 0);
+						await processCachedTask({
+							cache,
+							cacheKey: file,
+							hashKey: `${file}:js`,
+							hash: `${getSnapshotHash(snapshot.sourceHashByFile, file, initialRawSource)}:${hashSalt}`,
+							applyResult(source) {
+								originalSource.code = source;
+							},
+							onCacheHit() {
+								metrics.js.cacheHits++;
+								debug("js cache hit: %s", file);
+							},
+							async transform() {
+								const start = performance.now();
+								const rawSource = originalSource.code;
+								if (!shouldTransformJs) debug("js cache replay miss, fallback transform: %s", file);
+								const handlerOptions = createHandlerOptions(absoluteFile);
+								if (!disableJsPrecheck && shouldSkipJsTransform(rawSource, handlerOptions)) {
+									metrics.js.elapsed += measureElapsed(start);
+									metrics.js.transformed++;
+									return { result: rawSource };
+								}
+								const { code, linked } = await jsHandler(rawSource, transformRuntime, handlerOptions);
+								metrics.js.elapsed += measureElapsed(start);
+								metrics.js.transformed++;
+								onUpdate(file, rawSource, code);
+								debug("js handle: %s", file);
+								collectLinkedFileNames(linked, getJsEntry, linkedSet);
+								applyLinkedUpdates(linked);
+								return { result: code };
+							}
+						});
+					});
+				});
+			} else if (uniAppX && originalSource.type === "asset") {
+				const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
+				if (linkedByEntry && linkedSet) linkedByEntry.set(file, linkedSet);
+				const baseApplyLinkedUpdates = applyLinkedUpdates;
+				const wrappedApplyLinkedUpdates = (linked) => {
+					collectLinkedFileNames(linked, getJsEntry, linkedSet);
+					baseApplyLinkedUpdates(linked);
+				};
+				const factory = createUniAppXAssetTask(file, originalSource, outDir, {
+					cache,
+					hashKey: `${file}:js`,
+					hashSalt: createJsHashSalt(runtimeSignature, useIncrementalMode ? createLinkedImpactSignature(file, snapshot.linkedImpactsByEntry, snapshot.sourceHashByFile) : void 0),
+					createHandlerOptions,
+					debug,
+					jsHandler,
+					onUpdate,
+					runtimeSet: transformRuntime,
+					applyLinkedResults: wrappedApplyLinkedUpdates,
+					uniAppX
+				});
+				jsTaskFactories.push(async () => {
+					await timeTask("js", async () => {
+						const start = performance.now();
+						if (!shouldTransformJs) {
+							debug("js skip transform (clean, uni-app-x), replay cache: %s", file);
+							await factory();
+							metrics.js.elapsed += measureElapsed(start);
+							metrics.js.transformed++;
+							return;
+						}
+						const currentSource = originalEntrySource;
+						const precheckOptions = createHandlerOptions(path.resolve(outDir, file), {
+							uniAppX: resolveUniAppXJsTransformEnabled(uniAppX),
+							babelParserOptions: {
+								plugins: ["typescript"],
+								sourceType: "unambiguous"
+							}
+						});
+						if (!disableJsPrecheck && shouldSkipJsTransform(currentSource, precheckOptions)) {
+							metrics.js.elapsed += measureElapsed(start);
+							metrics.js.transformed++;
+							return;
+						}
+						await factory();
+						metrics.js.elapsed += measureElapsed(start);
+						metrics.js.transformed++;
+					});
+				});
+			}
+		}
+		if (useIncrementalMode) for (const [key, remembered] of getRememberedCssSources?.() ?? []) {
+			const { outputFile: rememberedOutputFile, rawSource, sourceFile } = remembered;
+			const outputFile = resolveViteCssPipelineOutputFile(rememberedOutputFile, opts, rootDir, isWebGeneratorTarget);
+			const cssHandlerOptions = getCssHandlerOptions(sourceFile);
+			const cssRuntimeSignature = createCssRuntimeSignature(runtimeSignature, await createScopedGeneratorCandidateSignature(rawSource, sourceFile, generatorCandidateSignature, getSourceCandidatesForEntries, { includeFallbackSignature: cssHandlerOptions.isMainChunk }));
+			if (bundleFiles.includes(outputFile) || bundleFiles.includes(sourceFile) || getRememberedCssSignature?.(key) === cssRuntimeSignature) continue;
+			tasks.push(timeTask("css.replay", async () => {
+				const start = performance.now();
+				const generated = await generateCssByGenerator({
+					opts,
+					runtimeState,
+					runtime: generatorRuntime,
+					rawSource,
+					file: sourceFile,
+					cssHandlerOptions,
+					cssUserHandlerOptions: getCssUserHandlerOptions(sourceFile),
+					getSourceCandidatesForEntries,
+					styleHandler,
+					debug
+				});
+				const css = generated?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
+				setRememberedCssSignature?.(key, cssRuntimeSignature);
+				if (generated) {
+					registerGeneratorDependencies$1({ addWatchFile }, generated.dependencies);
+					recordCssAssetResult?.(outputFile, generated.css);
+					recordViteProcessedCssAssetResult?.(sourceFile, generated.css, { injectIntoMain: cssHandlerOptions.isMainChunk });
+					debug("css replay generated result: %s bytes=%d", outputFile, css.length);
+				}
+				const replayAsset = createReplayCssAsset(outputFile, css);
+				if (typeof this.emitFile === "function") this.emitFile({
+					type: "asset",
+					fileName: outputFile,
+					source: css
+				});
+				else bundle[outputFile] = replayAsset;
+				markCssAssetProcessed?.(replayAsset, outputFile);
+				metrics.css.elapsed += measureElapsed(start);
+				metrics.css.transformed++;
+				onUpdate(outputFile, rawSource, css);
+				debug("css replay handle: %s", outputFile);
+			}));
+		}
+		pushConcurrentTaskFactories(tasks, jsTaskFactories);
+		const tasksStart = performance.now();
+		await Promise.all(tasks);
+		recordTimingDetail("tasks", tasksStart);
+		for (const apply of pendingLinkedUpdates) apply();
+		injectViteProcessedCssIntoMainCssAssets(bundle, {
+			opts,
+			getViteProcessedCssAssetResults,
+			markCssAssetProcessed,
+			recordCssAssetResult,
+			debug,
+			onUpdate
+		});
+		const stateUpdateStart = performance.now();
+		updateBundleBuildState(state, snapshot, useIncrementalMode ? linkedByEntry ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(), { incremental: useIncrementalMode });
+		state.generatorCandidateSignature = generatorCandidateSignature;
+		recordTimingDetail("state.update", stateUpdateStart);
+		debug("metrics iteration=%d runtime=%sms html(total=%d transform=%d hit=%d rate=%s elapsed=%sms) js(total=%d transform=%d hit=%d rate=%s elapsed=%sms) css(total=%d transform=%d hit=%d rate=%s elapsed=%sms)", useIncrementalMode ? state.iteration : 0, formatMs(metrics.runtimeSet), metrics.html.total, metrics.html.transformed, metrics.html.cacheHits, formatCacheHitRate(metrics.html), formatMs(metrics.html.elapsed), metrics.js.total, metrics.js.transformed, metrics.js.cacheHits, formatCacheHitRate(metrics.js), formatMs(metrics.js.elapsed), metrics.css.total, metrics.css.transformed, metrics.css.cacheHits, formatCacheHitRate(metrics.css), formatMs(metrics.css.elapsed));
+		if (hmrTimingRecorder) {
+			hmrTimingRecorder.record("generateBundle", performance.now() - hmrTimingStartedAt, timingDetails);
+			hmrTimingRecorder.emitTotal();
+		}
+		onEnd();
+		debug("end");
+	};
+}
+//#endregion
+//#region src/bundlers/vite/css-finalizer.ts
+function isAddWatchFileInvalidRollupPhaseError(error) {
+	const candidate = error;
+	return candidate?.code === "INVALID_ROLLUP_PHASE" || candidate?.pluginCode === "INVALID_ROLLUP_PHASE" || candidate?.message?.includes("Cannot call \"addWatchFile\" after the build has finished.") === true;
+}
+function registerGeneratorDependencies(ctx, dependencies) {
+	if (typeof ctx.addWatchFile !== "function") return;
+	for (const dependency of dependencies ?? []) try {
+		ctx.addWatchFile(dependency);
+	} catch (error) {
+		if (isAddWatchFileInvalidRollupPhaseError(error)) {
+			logger.debug("跳过生成模式依赖监听注册，当前 Rollup 阶段不允许 addWatchFile: %s", dependency);
+			continue;
+		}
+		throw error;
+	}
+}
+function createCssHandlerOptions(opts, majorVersion, file) {
+	return {
+		isMainChunk: opts.mainCssChunkMatcher(file, opts.appType),
+		postcssOptions: { options: { from: file } },
+		...majorVersion === void 0 ? {} : { majorVersion }
+	};
+}
+function shouldGenerateCssByGenerator(opts, file, rawSource, processed) {
+	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+	if (generatorOptions.target === "web" && opts.twPatcher.majorVersion !== 3) return false;
+	if (hasTailwindGeneratedCssMarkers(rawSource) || hasTailwindSourceDirectives(rawSource, { importFallback: generatorOptions.importFallback })) return true;
+	if (opts.twPatcher.majorVersion === 3) return false;
+	return processed && shouldFinalizeProcessedCssAsset(opts, file);
+}
+function shouldFinalizeProcessedCssAsset(opts, file) {
+	return opts.mainCssChunkMatcher(file, opts.appType);
+}
+function createViteCssFinalizerOutputPlugin(context) {
+	return {
+		name: "weapp-tailwindcss:adaptor:css-finalizer",
+		enforce: "post",
+		generateBundle: {
+			order: "post",
+			async handler(_options, bundle) {
+				const { opts, runtimeState, ensureRuntimeClassSet, isCssAssetProcessed, markCssAssetProcessed, debug, getResolvedConfig, recordCssAssetResult, recordViteProcessedCssAssetResult, getViteProcessedCssAssetResults, getRecordedGeneratorCandidates, getSourceCandidates, getSourceCandidatesForEntries, waitForSourceCandidateSyncs, rememberMainCssSource, getRememberedMainCssSource, isViteProcessedCssAsset } = context;
+				const resolvedConfig = getResolvedConfig();
+				if (resolvedConfig?.command !== "build") return;
+				const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+				const isWebGeneratorTarget = generatorOptions.target === "web";
+				const rootDir = resolvedConfig.root ? path.resolve(resolvedConfig.root) : process.cwd();
+				collectViteProcessedCssAssetResults(bundle, {
+					opts,
+					isViteProcessedCssAsset,
+					markCssAssetProcessed,
+					recordCssAssetResult,
+					recordViteProcessedCssAssetResult,
+					resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget),
+					debug
+				});
+				const isCssOutputAssetEntry = (entry) => {
+					const [, output] = entry;
+					return output.type === "asset" && opts.cssMatcher(output.fileName) && !isCssAssetProcessed(output, output.fileName);
+				};
+				const entries = Object.entries(bundle).filter(isCssOutputAssetEntry);
+				if (entries.length === 0) {
+					injectViteProcessedCssIntoMainCssAssets(bundle, {
+						opts,
+						getViteProcessedCssAssetResults,
+						markCssAssetProcessed,
+						recordCssAssetResult,
+						debug,
+						onUpdate: opts.onUpdate
+					});
+					return;
+				}
+				await runtimeState.readyPromise;
+				await waitForSourceCandidateSyncs?.();
+				const runtime = getRecordedGeneratorCandidates?.() ?? getSourceCandidates?.() ?? await ensureRuntimeClassSet();
+				const collectedGeneratorCandidates = new Set([...runtime, ...getSourceCandidates?.() ?? []]);
+				const generatorRuntime = runtimeState.twPatcher.majorVersion === 4 && generatorOptions.target === "weapp" ? filterUnsupportedMiniProgramTailwindV4Candidates(collectedGeneratorCandidates) : collectedGeneratorCandidates;
+				await Promise.all(entries.map(async ([bundleFile, output]) => {
+					const file = output.fileName || bundleFile;
+					const rawSource = output.source.toString();
+					if (isViteProcessedCssAsset?.(output, file)) {
+						const nextCss = stripBundlerGeneratedCssMarkers(rawSource);
+						output.source = nextCss;
+						markCssAssetProcessed(output, file);
+						recordCssAssetResult?.(file, nextCss);
+						debug("css finalizer skip vite-processed css: %s", file);
+						return;
+					}
+					const cssHandlerOptions = createCssHandlerOptions(opts, runtimeState.twPatcher.majorVersion, file);
+					const cssUserHandlerOptions = {
+						...cssHandlerOptions,
+						isMainChunk: false
+					};
+					const processed = isCssAssetProcessed(output, file);
+					const rememberedMainCssSource = processed && cssHandlerOptions.isMainChunk ? getRememberedMainCssSource?.(file) : void 0;
+					const generatorRawSource = rememberedMainCssSource?.rawSource ?? rawSource;
+					const generatorSourceFile = rememberedMainCssSource?.sourceFile ?? file;
+					const generatorCssHandlerOptions = rememberedMainCssSource ? createCssHandlerOptions(opts, runtimeState.twPatcher.majorVersion, generatorSourceFile) : cssHandlerOptions;
+					const generatorCssUserHandlerOptions = rememberedMainCssSource ? {
+						...generatorCssHandlerOptions,
+						isMainChunk: false
+					} : cssUserHandlerOptions;
+					const generated = shouldGenerateCssByGenerator(opts, file, generatorRawSource, processed) ? await generateCssByGenerator({
+						opts,
+						runtimeState,
+						runtime: generatorRuntime,
+						rawSource: generatorRawSource,
+						file: generatorSourceFile,
+						cssHandlerOptions: generatorCssHandlerOptions,
+						cssUserHandlerOptions: generatorCssUserHandlerOptions,
+						getSourceCandidatesForEntries,
+						styleHandler: opts.styleHandler,
+						debug
+					}) : void 0;
+					const nextCss = generated?.css ?? (generatorOptions.target === "web" ? rawSource : (await opts.styleHandler(rawSource, cssHandlerOptions)).css);
+					if (generated) {
+						registerGeneratorDependencies(this, generated.dependencies);
+						debug("css finalizer generated result: %s bytes=%d", file, nextCss.length);
+						recordCssAssetResult?.(file, nextCss);
+						if (cssHandlerOptions.isMainChunk) rememberMainCssSource?.(file, generatorRawSource);
+					}
+					output.source = nextCss;
+					markCssAssetProcessed(output, file);
+					opts.onUpdate(file, rawSource, nextCss);
+					debug("css finalizer handle: %s", file);
+				}));
+				injectViteProcessedCssIntoMainCssAssets(bundle, {
+					opts,
+					getViteProcessedCssAssetResults,
+					markCssAssetProcessed,
+					recordCssAssetResult,
+					debug,
+					onUpdate: opts.onUpdate
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/vite/official-tailwind-plugins.ts
+const tailwindPostcssPluginNames = new Set(["tailwindcss", "@tailwindcss/postcss"]);
+function getPostcssPluginName(plugin) {
+	if (!plugin) return;
+	if (typeof plugin === "function" && "postcss" in plugin) try {
+		return getPostcssPluginName(plugin());
+	} catch {
+		return;
+	}
+	if (typeof plugin !== "object" || !("postcssPlugin" in plugin)) return;
+	const { postcssPlugin } = plugin;
+	return typeof postcssPlugin === "string" ? postcssPlugin : void 0;
+}
+function isTailwindPostcssPlugin(plugin) {
+	const name = getPostcssPluginName(plugin);
+	return typeof name === "string" && tailwindPostcssPluginNames.has(name);
+}
+function removeTailwindPostcssPlugins(plugins) {
+	let removed = 0;
+	for (let i = plugins.length - 1; i >= 0; i--) if (isTailwindPostcssPlugin(plugins[i])) {
+		plugins.splice(i, 1);
+		removed++;
+	}
+	return removed;
+}
+function isTailwindVitePlugin(plugin) {
+	if (!plugin || typeof plugin !== "object" || !("name" in plugin)) return false;
+	const { name } = plugin;
+	return typeof name === "string" && name.startsWith("@tailwindcss/vite");
+}
+function removeTailwindVitePlugins(plugins) {
+	let removed = 0;
+	for (let i = plugins.length - 1; i >= 0; i--) if (isTailwindVitePlugin(plugins[i])) {
+		plugins.splice(i, 1);
+		removed++;
+	}
+	return removed;
+}
+function disableTailwindVitePlugin(plugin) {
+	if (!isTailwindVitePlugin(plugin)) return false;
+	const mutablePlugin = plugin;
+	for (const hook of [
+		"configResolved",
+		"configureServer",
+		"transform",
+		"hotUpdate",
+		"handleHotUpdate"
+	]) delete mutablePlugin[hook];
+	return true;
+}
+function disableAndRemoveTailwindVitePlugins(plugins) {
+	let removed = 0;
+	for (let i = plugins.length - 1; i >= 0; i--) {
+		const plugin = plugins[i];
+		if (Array.isArray(plugin)) {
+			removed += disableAndRemoveTailwindVitePlugins(plugin);
+			if (plugin.length === 0) plugins.splice(i, 1);
+			continue;
+		}
+		if (disableTailwindVitePlugin(plugin)) {
+			plugins.splice(i, 1);
+			removed++;
+		}
+	}
+	return removed;
+}
+//#endregion
+//#region src/bundlers/vite/postcss-config.ts
+async function resolveFilteredPostcssConfig(root) {
+	try {
+		const loaded = await postcssrc({}, root);
+		const plugins = Array.isArray(loaded.plugins) ? [...loaded.plugins] : [];
+		const removed = removeTailwindPostcssPlugins(plugins);
+		if (removed === 0) return;
+		return {
+			options: loaded.options,
+			plugins,
+			removed
+		};
+	} catch (error) {
+		if ((error instanceof Error ? error.message : String(error)).includes("No PostCSS Config found")) return;
+		throw error;
+	}
+}
+//#endregion
+//#region src/bundlers/vite/resolve-app-type.ts
+const PACKAGE_JSON_FILE$1 = "package.json";
+const MPX_SCRIPT_RE = /\bmpx(?:-cli-service)?\b/u;
+const TARO_SCRIPT_RE = /\btaro\b/u;
+const TAILWINDCSS_VITE_MARKERS = [["src/app.mpx", "mpx"], ["app.mpx", "mpx"]];
+function resolveDependencyNames(pkg) {
+	return new Set([
+		...Object.keys(pkg.dependencies ?? {}),
+		...Object.keys(pkg.devDependencies ?? {}),
+		...Object.keys(pkg.peerDependencies ?? {}),
+		...Object.keys(pkg.optionalDependencies ?? {})
+	]);
+}
+function hasScriptMatch(pkg, pattern) {
+	return Object.values(pkg.scripts ?? {}).some((script) => pattern.test(script));
+}
+function resolveAppTypeFromPackageJson(pkg) {
+	const dependencyNames = resolveDependencyNames(pkg);
+	if (dependencyNames.has("weapp-vite") || [...dependencyNames].some((name) => name.startsWith("@weapp-vite/"))) return "weapp-vite";
+	if ([...dependencyNames].some((name) => name.startsWith("@mpxjs/")) || hasScriptMatch(pkg, MPX_SCRIPT_RE)) return "mpx";
+	if ([...dependencyNames].some((name) => name.startsWith("@tarojs/")) || hasScriptMatch(pkg, TARO_SCRIPT_RE)) return "taro";
+	if (dependencyNames.has("@dcloudio/vite-plugin-uni")) return "uni-app-vite";
+	if (dependencyNames.has("@dcloudio/vue-cli-plugin-uni") || dependencyNames.has("@dcloudio/uni-app") || Object.hasOwn(pkg, "uni-app")) return "uni-app";
+}
+function tryReadUniAppManifest(root) {
+	const manifestPath = path.join(root, "manifest.json");
+	if (!existsSync(manifestPath)) return;
+	try {
+		return JSON.parse(readFileSync(manifestPath, "utf8"));
+	} catch {}
+}
+function tryReadPackageJson(root) {
+	const packageJsonPath = path.join(root, PACKAGE_JSON_FILE$1);
+	if (!existsSync(packageJsonPath)) return;
+	try {
+		return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+	} catch {}
+}
+function resolveAppTypeFromMarkers(root) {
+	for (const [relativePath, appType] of TAILWINDCSS_VITE_MARKERS) if (existsSync(path.join(root, relativePath))) return appType;
+}
+function resolveImplicitAppTypeFromViteRoot(root) {
+	const resolvedRoot = path.resolve(root);
+	if (!existsSync(resolvedRoot)) return;
+	const markerDetected = resolveAppTypeFromMarkers(resolvedRoot);
+	if (markerDetected) return markerDetected;
+	let current = resolvedRoot;
+	while (true) {
+		const manifest = tryReadUniAppManifest(current);
+		if (manifest && Object.hasOwn(manifest, "uni-app-x")) return "uni-app-x";
+		const pkg = tryReadPackageJson(current);
+		if (pkg) {
+			const detected = resolveAppTypeFromPackageJson(pkg);
+			if (detected) return detected;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+}
+//#endregion
+//#region src/bundlers/shared/css-imports.ts
+const tailwindcssImportRE = /^(?:tailwindcss|weapp-tailwindcss)(?:\/.*)?$/;
+const tailwindcssCssImportStatementRE = /(@import\s+(?:url\(\s*)?)(["'])((?:tailwindcss|weapp-tailwindcss)(?:\/[^"']*)?\$?)(\2\s*\)?)/gi;
+function normalizeTailwindcssSpecifier(specifier) {
+	if (specifier === "tailwindcss$" || specifier === "weapp-tailwindcss$") return specifier.slice(0, -1);
+	return specifier;
+}
+function getTailwindcssSubpath(specifier) {
+	if (specifier === "tailwindcss" || specifier === "weapp-tailwindcss") return "index.css";
+	return specifier.replace(/^(?:tailwindcss|weapp-tailwindcss)\//, "");
+}
+function resolveTailwindcssImport(specifier, pkgDir, options) {
+	const normalized = normalizeTailwindcssSpecifier(specifier);
+	if (!tailwindcssImportRE.test(normalized)) return null;
+	if (normalized === "tailwindcss" || normalized === "weapp-tailwindcss") return options?.rootImport ?? (options?.join ?? path.join)(pkgDir, "index.css");
+	return (options?.join ?? path.join)(pkgDir, getTailwindcssSubpath(normalized));
+}
+function rewriteTailwindcssImportsInCode(code, pkgDir, options) {
+	let hasReplacements = false;
+	const rewritten = code.replace(tailwindcssCssImportStatementRE, (full, prefix, quote, specifier, suffix) => {
+		const replacement = resolveTailwindcssImport(specifier, pkgDir, options);
+		if (!replacement) return full;
+		hasReplacements = true;
+		return `${prefix}${quote}${replacement}${suffix}`;
+	});
+	return hasReplacements ? rewritten : void 0;
+}
+//#endregion
+//#region src/bundlers/vite/rewrite-css-imports.ts
+function joinPosixPath(base, subpath) {
+	if (base.endsWith("/")) return `${base}${subpath}`;
+	return `${base}/${subpath}`;
+}
+function isCssLikeImporter(importer) {
+	if (!importer) return false;
+	const normalized = cleanUrl(importer);
+	return isSourceStyleRequest(importer) || isCSSRequest(normalized) || normalized.endsWith("/*");
+}
+function stripTailwindConfigDirectives(code) {
+	return code.replace(/^\s*@config\s+(?:"[^"]+"|'[^']+')[^;\n]*;\s*$/gm, "");
+}
+function createRewriteCssImportsPlugins(options) {
+	if (!options.shouldRewrite && !options.shouldOwnTailwindGeneration) return [];
+	const { appType, getAppType, rootImport, shouldOwnTailwindGeneration, weappTailwindcssDirPosix } = options;
+	const resolveAppType = () => getAppType?.() ?? appType;
+	return [{
+		name: `${vitePluginName}:rewrite-css-imports`,
+		enforce: "pre",
+		resolveId(id, importer) {
+			if (!options.shouldRewrite) return null;
+			const replacement = resolveTailwindcssImport(id, weappTailwindcssDirPosix, {
+				join: joinPosixPath,
+				appType: resolveAppType(),
+				rootImport
+			});
+			if (!replacement) return null;
+			if (importer && !isCssLikeImporter(importer)) return null;
+			return replacement;
+		},
+		async transform(code, id) {
+			if (!isCSSRequest(id)) return null;
+			const file = cleanUrl(id);
+			const normalizedCode = hasTailwindRootDirectives(code) ? normalizeTailwindConfigDirectives(code, path.dirname(file)) : code;
+			if (hasTailwindRootDirectives(normalizedCode)) {
+				await options.onTailwindRootCss?.(id, normalizedCode);
+				if (options.shouldOwnTailwindGeneration) {
+					const generatedCss = await options.generateTailwindCss?.(id, normalizedCode, this);
+					if (generatedCss !== void 0) return {
+						code: generatedCss,
+						map: null
+					};
+				}
+			}
+			if (!options.shouldRewrite) return null;
+			const rewritten = rewriteTailwindcssImportsInCode(normalizedCode, weappTailwindcssDirPosix, {
+				join: joinPosixPath,
+				appType: resolveAppType(),
+				rootImport
+			});
+			const nextCode = shouldOwnTailwindGeneration ? stripTailwindConfigDirectives(rewritten ?? normalizedCode) : rewritten;
+			if (!nextCode || nextCode === code) return null;
+			return {
+				code: nextCode,
+				map: null
+			};
+		}
+	}];
+}
+//#endregion
+//#region src/bundlers/vite/runtime-class-set.ts
+function createViteRuntimeClassSet(options) {
+	const { opts, initialTwPatcher, refreshTailwindcssPatcher, uniAppXEnabled, customAttributesEntities, disabledDefaultTemplateHandler, debug } = options;
+	const runtimeState = {
+		twPatcher: initialTwPatcher,
+		readyPromise: createTailwindRuntimeReadyPromise(initialTwPatcher),
+		refreshTailwindcssPatcher
+	};
+	const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager({ bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues });
+	const transformRuntimeClassSetManager = createBundleRuntimeClassSetManager({ bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues });
+	let runtimeSet;
+	let runtimeSetPromise;
+	let runtimeRefreshSignature;
+	let runtimeRefreshOptionsKey;
+	function resolveRuntimeRefreshOptions() {
+		const configPath = resolveTailwindcssOptions(runtimeState.twPatcher.options)?.config;
+		const signature = getRuntimeClassSetSignature(runtimeState.twPatcher);
+		const optionsKey = JSON.stringify({
+			appType: opts.appType,
+			uniAppX: uniAppXEnabled,
+			customAttributesEntities,
+			disabledDefaultTemplateHandler,
+			configPath
+		});
+		const changed = signature !== runtimeRefreshSignature || optionsKey !== runtimeRefreshOptionsKey;
+		runtimeRefreshSignature = signature;
+		runtimeRefreshOptionsKey = optionsKey;
+		return {
+			changed,
+			signature,
+			optionsKey
+		};
+	}
+	async function refreshRuntimeState(force) {
+		const invalidation = resolveRuntimeRefreshOptions();
+		const refreshed = await refreshTailwindRuntimeState(runtimeState, {
+			force: force || invalidation.changed,
+			clearCache: force || invalidation.changed
+		});
+		if (invalidation.changed) debug("runtime signature changed, refresh triggered. signature: %s", invalidation.signature);
+		if (refreshed) {
+			runtimeSet = void 0;
+			runtimeSetPromise = void 0;
+		}
+	}
+	async function ensureRuntimeClassSet(force = false) {
+		const forceRuntimeRefresh = force || process.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1";
+		await refreshRuntimeState(force);
+		await runtimeState.readyPromise;
+		if (!forceRuntimeRefresh && runtimeSet) return runtimeSet;
+		if (forceRuntimeRefresh || !runtimeSetPromise) {
+			const invalidation = resolveRuntimeRefreshOptions();
+			runtimeSetPromise = collectRuntimeClassSet(runtimeState.twPatcher, {
+				force: forceRuntimeRefresh || invalidation.changed,
+				skipRefresh: forceRuntimeRefresh,
+				clearCache: forceRuntimeRefresh || invalidation.changed
+			});
+		}
+		const task = runtimeSetPromise;
+		try {
+			runtimeSet = await task;
+			return runtimeSet;
+		} finally {
+			if (runtimeSetPromise === task) runtimeSetPromise = void 0;
+		}
+	}
+	async function ensureBundleRuntimeClassSet(snapshot, forceRefresh = false, options = {}) {
+		const forceRuntimeRefresh = forceRefresh || process.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1";
+		const invalidation = resolveRuntimeRefreshOptions();
+		const shouldRefreshPatcher = forceRuntimeRefresh || invalidation.changed;
+		const forceCollectBySource = snapshot.runtimeAffectingChangedByType.html.size > 0 || snapshot.runtimeAffectingChangedByType.js.size > 0;
+		await refreshRuntimeState(shouldRefreshPatcher);
+		await runtimeState.readyPromise;
+		if (shouldRefreshPatcher) {
+			runtimeSet = void 0;
+			runtimeSetPromise = void 0;
+			await bundleRuntimeClassSetManager.reset();
+			await transformRuntimeClassSetManager.reset();
+		}
+		if (runtimeState.twPatcher.majorVersion === 4 && !forceRuntimeRefresh) try {
+			const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot);
+			runtimeSet = nextRuntimeSet;
+			return nextRuntimeSet;
+		} catch (error) {
+			debug("incremental runtime set sync failed, fallback to full collect: %O", error);
+			await bundleRuntimeClassSetManager.reset();
+		}
+		if (runtimeState.twPatcher.majorVersion === 3 && !forceRuntimeRefresh) {
+			if (options.transformOnly) try {
+				return await transformRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot);
+			} catch (error) {
+				debug("incremental transform runtime set sync failed, fallback to full collect: %O", error);
+				await transformRuntimeClassSetManager.reset();
+			}
+			try {
+				let baseClassSet = options.baseClassSet;
+				if (!baseClassSet && (!runtimeSet || shouldRefreshPatcher)) baseClassSet = await collectRuntimeClassSet(runtimeState.twPatcher, {
+					force: true,
+					skipRefresh: shouldRefreshPatcher,
+					clearCache: shouldRefreshPatcher
+				});
+				const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot, {
+					baseClassSet: baseClassSet ?? (options.allowBaselineOnlyInitialSync === true ? runtimeSet : void 0),
+					skipInitialFullScanWithBase: options.allowBaselineOnlyInitialSync === true && Boolean(runtimeSet)
+				});
+				runtimeSet = nextRuntimeSet;
+				return nextRuntimeSet;
+			} catch (error) {
+				debug("incremental runtime set sync failed, fallback to full collect: %O", error);
+				await bundleRuntimeClassSetManager.reset();
+			}
+		}
+		if (!forceRuntimeRefresh && !invalidation.changed && !forceCollectBySource && runtimeSet) return runtimeSet;
+		const task = collectRuntimeClassSet(runtimeState.twPatcher, {
+			force: forceRuntimeRefresh || invalidation.changed || forceCollectBySource,
+			skipRefresh: forceRuntimeRefresh,
+			clearCache: forceRuntimeRefresh || invalidation.changed
+		});
+		runtimeSetPromise = task;
+		try {
+			runtimeSet = await task;
+			return runtimeSet;
+		} finally {
+			if (runtimeSetPromise === task) runtimeSetPromise = void 0;
+		}
+	}
+	return {
+		runtimeState,
+		refreshRuntimeState,
+		ensureRuntimeClassSet,
+		ensureBundleRuntimeClassSet
+	};
+}
+//#endregion
+//#region src/bundlers/vite/serve-css-generation.ts
+const SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
+const COMMON_JS_PROXY_RE = /\?commonjs-proxy/;
+const VITE_CSS_HMR_MODULE_RE = /\b__vite__updateStyle\s*\(/;
+const VITE_CSS_CONST_RE = /\bconst\s+__vite__css\s*=\s*("(?:\\[\s\S]|[^"])*")/;
+function decodeJsStringLiteral(literal) {
+	try {
+		return JSON.parse(literal);
+	} catch {
+		return;
+	}
+}
+function encodeJsStringLiteral(value) {
+	return JSON.stringify(value);
+}
+function extractViteCssHmrModuleCss(code) {
+	const match = VITE_CSS_CONST_RE.exec(code);
+	if (!match?.[1]) return;
+	const css = decodeJsStringLiteral(match[1]);
+	if (typeof css !== "string") return;
+	return {
+		css,
+		start: match.index + match[0].lastIndexOf(match[1]),
+		end: match.index + match[0].length
+	};
+}
+function replaceViteCssHmrModuleCss(code, css) {
+	const extracted = extractViteCssHmrModuleCss(code);
+	if (!extracted) return;
+	return `${code.slice(0, extracted.start)}${encodeJsStringLiteral(css)}${code.slice(extracted.end)}`;
+}
+function isViteServeStyleRequest(id, command) {
+	return command === "serve" && isSourceStyleRequest(id) && !SPECIAL_QUERY_RE.test(id) && !COMMON_JS_PROXY_RE.test(id);
+}
+function isViteServeCssRootRequest(id, command) {
+	return command === "serve" && isCSSRequest(id) && !SPECIAL_QUERY_RE.test(id) && !COMMON_JS_PROXY_RE.test(id);
+}
+function isViteCssHmrModule(code, id, command) {
+	return isViteServeStyleRequest(id, command) && VITE_CSS_HMR_MODULE_RE.test(code) && /[?&](?:direct|vue)(?:&|$)/.test(id);
+}
+function createViteServeCssGenerationPlugins(options) {
+	return [{
+		name: `${vitePluginName}:generate:serve`,
+		apply: "serve",
+		enforce: "pre",
+		async transform(code, id) {
+			if (!options.shouldGenerate() || !isViteServeCssRootRequest(id, options.getCommand())) return;
+			if (!hasTailwindRootDirectives(code)) return;
+			await options.onTailwindRootCss?.(id, code);
+			const generatedCss = await options.generateCss(id, code, this);
+			if (generatedCss === void 0 || generatedCss === code) return;
+			return {
+				code: generatedCss,
+				map: null
+			};
+		}
+	}, {
+		name: `${vitePluginName}:generate:serve-hmr`,
+		apply: "serve",
+		enforce: "post",
+		async transform(code, id) {
+			if (!options.shouldGenerate() || !isViteCssHmrModule(code, id, options.getCommand())) return;
+			const extracted = extractViteCssHmrModuleCss(code);
+			if (!extracted) return;
+			await options.onTailwindRootCss?.(id, extracted.css);
+			const generatedCss = await options.generateCss(id, extracted.css, this);
+			if (generatedCss === void 0 || generatedCss === extracted.css) return;
+			const nextCode = replaceViteCssHmrModuleCss(code, generatedCss);
+			if (nextCode === void 0 || nextCode === code) return;
+			return {
+				code: nextCode,
+				map: null
+			};
+		}
+	}];
+}
+//#endregion
+//#region src/bundlers/vite/tailwind-basedir.ts
+const PACKAGE_JSON_FILE = "package.json";
+function resolveImplicitTailwindcssBasedirFromViteRoot(root) {
+	const resolvedRoot = path.resolve(root);
+	if (!existsSync(resolvedRoot)) return resolvedRoot;
+	const searchRoots = [];
+	let current = resolvedRoot;
+	while (true) {
+		searchRoots.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	const tailwindConfigPath = findTailwindConfig(searchRoots);
+	if (tailwindConfigPath) return path.dirname(tailwindConfigPath);
+	const packageRoot = findNearestPackageRoot(resolvedRoot);
+	if (packageRoot && existsSync(path.join(packageRoot, PACKAGE_JSON_FILE))) return packageRoot;
+	return resolvedRoot;
+}
+//#endregion
+//#region src/bundlers/vite/index.ts
+const debug = createDebug();
+const weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
+const weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
+const sourceCandidateScanSnapshotCache = /* @__PURE__ */ new Map();
+function normalizeSignaturePath(value) {
+	return slash(path.resolve(value));
+}
+function serializeInlineCandidates(inlineCandidates) {
+	return {
+		excluded: [...inlineCandidates?.excluded ?? []].sort(),
+		included: [...inlineCandidates?.included ?? []].sort()
+	};
+}
+function serializeSourceEntries(entries) {
+	return (entries ?? []).map((entry) => ({
+		base: normalizeSignaturePath(entry.base),
+		negated: entry.negated,
+		pattern: entry.pattern
+	})).sort((a, b) => `${a.base}\0${a.pattern}\0${a.negated}`.localeCompare(`${b.base}\0${b.pattern}\0${b.negated}`));
+}
+function createSourceCandidateScanSignature(input) {
+	return JSON.stringify({
+		inlineCandidates: serializeInlineCandidates(input.inlineCandidates),
+		outDir: input.outDir ? normalizeSignaturePath(input.outDir) : void 0,
+		roots: input.roots.map((root) => ({
+			entries: serializeSourceEntries(root.entries),
+			root: normalizeSignaturePath(root.root)
+		})),
+		scanAllSources: input.scanAllSources ?? false
+	});
+}
+/**
+* @name WeappTailwindcss
+* @description uni-app vite / uni-app-x 版本插件
+* @link https://tw.icebreaker.top/docs/quick-start/frameworks/uni-app-vite
+*/
+function WeappTailwindcss(options = {}) {
+	const hasExplicitAppType = typeof options.appType === "string" && options.appType.trim().length > 0;
+	const hasExplicitTailwindcssBasedir = typeof options.tailwindcssBasedir === "string" && options.tailwindcssBasedir.trim().length > 0;
+	const opts = getCompilerContext({
+		...options,
+		__internalDeferMissingCssEntriesWarning: true
+	});
+	const normalizedCssEntries = normalizeCssEntries(options.cssEntries, opts.tailwindcssBasedir ?? process.cwd());
+	if (normalizedCssEntries) opts.cssEntries ?? (opts.cssEntries = normalizedCssEntries);
+	if (opts.cssEntries?.length) {
+		var _opts$tailwindcss, _opts$tailwindcss$v;
+		opts.tailwindcss ?? (opts.tailwindcss = {});
+		(_opts$tailwindcss = opts.tailwindcss).v4 ?? (_opts$tailwindcss.v4 = {});
+		(_opts$tailwindcss$v = opts.tailwindcss.v4).cssEntries ?? (_opts$tailwindcss$v.cssEntries = opts.cssEntries);
+	}
+	const { disabled, customAttributes, onLoad, mainCssChunkMatcher, styleHandler, jsHandler, twPatcher: initialTwPatcher, refreshTailwindcssPatcher, uniAppX, disabledDefaultTemplateHandler } = opts;
+	const uniAppXEnabled = isUniAppXEnabled(uniAppX);
+	const disabledOptions = resolvePluginDisabledState(disabled);
+	const tailwindcssMajorVersion = initialTwPatcher.majorVersion ?? 0;
+	const shouldOwnTailwindGeneration = !disabledOptions.plugin;
+	const shouldRewriteCssImports = tailwindcssMajorVersion >= 4;
+	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+	const shouldInferAppType = !hasExplicitAppType && generatorOptions.target !== "web";
+	const hasInitialTailwindCssRoots = hasConfiguredTailwindV4CssRoots({
+		...options,
+		cssEntries: opts.cssEntries ?? options.cssEntries
+	});
+	const autoCssSourceContent = /* @__PURE__ */ new Map();
+	let refreshRuntimeStateForAutoCssSources;
+	let autoCssSourcesRefresh;
+	let autoCssSourcesDiscovered = false;
+	const syncTailwindCssSourceCandidates = async (id, css) => {
+		await sourceCandidateCollector.syncCss(id, css);
+		cacheCurrentSourceCandidateScan();
+	};
+	const registerAutoCssSource = async (id, css, options = {}) => {
+		if (tailwindcssMajorVersion < 4 || !shouldOwnTailwindGeneration || hasInitialTailwindCssRoots) return;
+		const file = cleanUrl(id);
+		if (!path.isAbsolute(file)) return;
+		const sourceFile = path.normalize(file);
+		const sourceBase = path.dirname(sourceFile);
+		const sourceCss = normalizeTailwindSourceForGenerator(normalizeTailwindConfigDirectives(css, sourceBase), { importFallback: true });
+		if (autoCssSourceContent.get(sourceFile) === sourceCss) return;
+		autoCssSourceContent.set(sourceFile, sourceCss);
+		await syncTailwindCssSourceCandidates(sourceFile, sourceCss);
+		if (!upsertTailwindV4CssSource(opts, {
+			file: sourceFile,
+			base: sourceBase,
+			css: sourceCss,
+			dependencies: await resolveViteTailwindV4CssDependencies(sourceCss, sourceBase)
+		})) return;
+		invalidateSourceCandidateScan();
+		debug("detected tailwindcss v4 css source from vite css module: %s", sourceFile);
+		if (options.refresh === false) return;
+		autoCssSourcesRefresh = (autoCssSourcesRefresh ?? Promise.resolve()).then(async () => {
+			await refreshRuntimeStateForAutoCssSources?.(true);
+			await syncSourceCandidateScan({ force: true });
+		});
+		await autoCssSourcesRefresh;
+	};
+	const discoverAndRegisterAutoCssSources = async () => {
+		if (tailwindcssMajorVersion < 4 || !shouldOwnTailwindGeneration || hasInitialTailwindCssRoots || !resolvedConfig?.root) return;
+		const cssEntries = await discoverTailwindV4CssEntries(resolvedConfig.root, resolvedConfig.build?.outDir);
+		autoCssSourcesDiscovered = true;
+		let changed = false;
+		for (const cssEntry of cssEntries) {
+			const sourceFile = path.resolve(cssEntry);
+			const sourceBase = path.dirname(sourceFile);
+			const sourceCss = normalizeTailwindSourceForGenerator(normalizeTailwindConfigDirectives(await readFile(sourceFile, "utf8"), sourceBase), { importFallback: true });
+			if (autoCssSourceContent.get(sourceFile) === sourceCss) continue;
+			autoCssSourceContent.set(sourceFile, sourceCss);
+			await syncTailwindCssSourceCandidates(sourceFile, sourceCss);
+			changed = upsertTailwindV4CssSource(opts, {
+				file: sourceFile,
+				base: sourceBase,
+				css: sourceCss,
+				dependencies: (await resolveTailwindV4EntriesFromCssCached(sourceCss, sourceBase))?.dependencies ?? []
+			}) || changed;
+		}
+		if (!changed) return;
+		invalidateSourceCandidateScan();
+		await refreshRuntimeStateForAutoCssSources?.(true);
+	};
+	const customAttributesEntities = toCustomAttributesEntities(customAttributes);
+	let resolvedConfig;
+	let recordedGeneratorCandidates;
+	const sourceCandidateExtractor = tailwindcssMajorVersion === 3 ? createTailwindV3DefaultExtractor() : void 0;
+	const sourceCandidateCollector = createSourceCandidateCollector({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		extractor: sourceCandidateExtractor
+	});
+	const sourceCandidateScanCache = /* @__PURE__ */ new Map();
+	let sourceScanEntries;
+	let sourceScanMatcher;
+	let sourceScanDependencies = /* @__PURE__ */ new Set();
+	let sourceScanExplicit = false;
+	let sourceCandidateScanSignature;
+	let sourceCandidateScanInvalidated = true;
+	const pendingSourceCandidateSyncs = /* @__PURE__ */ new Set();
+	const pendingSourceCandidateSyncByFile = /* @__PURE__ */ new Map();
+	const processedCssAssets = /* @__PURE__ */ new WeakSet();
+	const viteProcessedCssSourceFiles = /* @__PURE__ */ new Set();
+	const viteGeneratedCssByFile = /* @__PURE__ */ new Map();
+	const viteProcessedCssAssetResults = /* @__PURE__ */ new Map();
+	const rememberedCssSources = /* @__PURE__ */ new Map();
+	const rememberedCssSignatureByFile = /* @__PURE__ */ new Map();
+	const tailwindRootCssModuleIds = /* @__PURE__ */ new Set();
+	const { runtimeState, refreshRuntimeState, ensureRuntimeClassSet, ensureBundleRuntimeClassSet } = createViteRuntimeClassSet({
+		opts,
+		initialTwPatcher,
+		refreshTailwindcssPatcher,
+		uniAppXEnabled,
+		customAttributesEntities,
+		disabledDefaultTemplateHandler,
+		debug
+	});
+	const hmrTimingRecorder = createHmrTimingRecorder("vite");
+	refreshRuntimeStateForAutoCssSources = refreshRuntimeState;
+	onLoad();
+	const getResolvedConfig = () => resolvedConfig;
+	const markCssAssetProcessed = (asset, _file) => {
+		processedCssAssets.add(asset);
+	};
+	const isCssAssetProcessed = (asset, file) => {
+		if (processedCssAssets.has(asset)) return true;
+		if (!file) return false;
+		const record = viteProcessedCssAssetResults.get(normalizeOutputPathKey(file));
+		if (!record) return false;
+		return (typeof asset.source === "string" ? asset.source : asset.source instanceof Uint8Array ? Buffer.from(asset.source).toString() : String(asset.source ?? "")) === record.css;
+	};
+	const recordGeneratorCandidates = (candidates) => {
+		recordedGeneratorCandidates = new Set(candidates);
+	};
+	const getRecordedGeneratorCandidates = () => recordedGeneratorCandidates;
+	const invalidateRecordedGeneratorCandidates = () => {
+		recordedGeneratorCandidates = void 0;
+	};
+	const getSourceCandidates = () => sourceCandidateCollector.values();
+	const getSourceCandidatesForEntries = (entries) => sourceCandidateCollector.valuesForEntries(entries);
+	const isWatchBuild = () => resolvedConfig?.command === "build" && resolvedConfig.build.watch != null;
+	const isWatchLikeBuild = () => isWatchBuild() || resolvedConfig?.command === "serve" || process.env["WEAPP_TW_WATCH_REGRESSION"] === "1" || process.env["WEAPP_TW_HMR_TIMING"] === "1";
+	const hasSourceCandidateScanState = () => sourceCandidateScanSignature !== void 0;
+	const normalizeSourceScanDependency = (file) => path.normalize(path.resolve(cleanUrl(file)));
+	const isSourceScanDependency = (file) => sourceScanDependencies.has(normalizeSourceScanDependency(file));
+	const invalidateSourceCandidateScan = () => {
+		sourceCandidateScanInvalidated = true;
+	};
+	const collectSourceCandidateScanRoots = (root, entries) => {
+		if (entries?.length) return [{
+			entries,
+			explicit: sourceScanExplicit,
+			root
+		}];
+		if (sourceScanExplicit) return [];
+		const roots = [{
+			entries,
+			root
+		}];
+		const normalizedRoot = path.resolve(root);
+		const seenRoots = new Set([normalizedRoot]);
+		const basedir = opts.tailwindcssBasedir ? path.resolve(opts.tailwindcssBasedir) : void 0;
+		if (basedir && !seenRoots.has(basedir)) {
+			roots.push({ root: basedir });
+			seenRoots.add(basedir);
+		}
+		for (const cssEntry of opts.tailwindcss?.v4?.cssEntries ?? []) {
+			const cssEntryRoot = path.dirname(path.resolve(cssEntry));
+			if (seenRoots.has(cssEntryRoot)) continue;
+			roots.push({ root: cssEntryRoot });
+			seenRoots.add(cssEntryRoot);
+		}
+		return roots;
+	};
+	const scanSourceCandidateRoots = async (roots, outDir) => {
+		await Promise.all(roots.map((root) => sourceCandidateCollector.scanRoot({
+			entries: root.entries,
+			explicit: root.explicit,
+			root: root.root,
+			outDir
+		})));
+	};
+	const cacheCurrentSourceCandidateScan = () => {
+		if (sourceCandidateScanSignature) {
+			sourceCandidateScanCache.set(sourceCandidateScanSignature, sourceCandidateCollector.snapshot());
+			sourceCandidateScanSnapshotCache.set(sourceCandidateScanSignature, sourceCandidateCollector.snapshot());
+		}
+	};
+	const shouldDiscoverAutoCssSources = () => {
+		if (!autoCssSourcesDiscovered) return true;
+		if (!isWatchLikeBuild()) return true;
+		return sourceCandidateScanInvalidated;
+	};
+	async function syncSourceCandidateScan(options = {}) {
+		if (!shouldOwnTailwindGeneration) return;
+		if (!options.force && isWatchLikeBuild() && hasSourceCandidateScanState() && !sourceCandidateScanInvalidated) {
+			debug("reuse vite source candidate scan definition for watch rebuild");
+			return;
+		}
+		const root = resolvedConfig?.root ?? process.cwd();
+		const outDir = resolvedConfig?.build?.outDir;
+		const sourceScan = await resolveViteSourceScanEntries(opts, runtimeState.twPatcher, {
+			outDir,
+			root
+		});
+		sourceScanEntries = sourceScan?.entries;
+		sourceScanExplicit = sourceScan?.explicit ?? false;
+		sourceScanMatcher = createViteSourceScanMatcher(sourceScanEntries);
+		sourceScanDependencies = new Set((sourceScan?.dependencies ?? []).map(normalizeSourceScanDependency));
+		const roots = collectSourceCandidateScanRoots(root, sourceScanEntries);
+		const nextScanSignature = createSourceCandidateScanSignature({
+			inlineCandidates: sourceScan?.inlineCandidates,
+			outDir,
+			roots,
+			scanAllSources: !sourceScanExplicit
+		});
+		if (hasSourceCandidateScanState() && sourceCandidateScanSignature === nextScanSignature) {
+			sourceCandidateCollector.syncInline(sourceScan?.inlineCandidates);
+			sourceCandidateScanCache.set(nextScanSignature, sourceCandidateCollector.snapshot());
+			debug("reuse vite source candidate scan for watch rebuild");
+			sourceCandidateScanInvalidated = false;
+			return;
+		}
+		const cachedScan = isWatchLikeBuild() ? sourceCandidateScanCache.get(nextScanSignature) ?? sourceCandidateScanSnapshotCache.get(nextScanSignature) : void 0;
+		if (cachedScan) {
+			sourceCandidateCollector.restore(cachedScan);
+			sourceCandidateScanSignature = nextScanSignature;
+			debug("reuse cached vite source candidate scan for watch rebuild");
+			sourceCandidateScanInvalidated = false;
+			return;
+		}
+		sourceCandidateCollector.clear();
+		sourceCandidateCollector.syncInline(sourceScan?.inlineCandidates);
+		await scanSourceCandidateRoots(roots, outDir);
+		sourceCandidateScanSignature = nextScanSignature;
+		sourceCandidateScanInvalidated = false;
+		if (isWatchLikeBuild()) {
+			sourceCandidateScanCache.set(nextScanSignature, sourceCandidateCollector.snapshot());
+			sourceCandidateScanSnapshotCache.set(nextScanSignature, sourceCandidateCollector.snapshot());
+		}
+	}
+	const waitForSourceCandidateSyncs = async () => {
+		while (pendingSourceCandidateSyncs.size > 0) await Promise.all(pendingSourceCandidateSyncs);
+	};
+	const syncChangedSourceCandidateFile = (id) => {
+		if (!shouldOwnTailwindGeneration || !isSourceCandidateRequest(id)) return Promise.resolve();
+		const file = cleanUrl(id);
+		if (isSourceScanDependency(file)) invalidateSourceCandidateScan();
+		if (sourceScanMatcher && !sourceScanMatcher(file)) {
+			sourceCandidateCollector.remove(file);
+			cacheCurrentSourceCandidateScan();
+			return Promise.resolve();
+		}
+		if (sourceScanExplicit && sourceScanEntries?.length === 0) {
+			cacheCurrentSourceCandidateScan();
+			return Promise.resolve();
+		}
+		const existingTask = pendingSourceCandidateSyncByFile.get(file);
+		if (existingTask) return existingTask;
+		const task = sourceCandidateCollector.syncCurrentFile(id).catch((error) => {
+			debug("source candidate watch sync failed: %s %O", id, error);
+		}).then(() => {
+			cacheCurrentSourceCandidateScan();
+		}).finally(() => {
+			pendingSourceCandidateSyncs.delete(task);
+			pendingSourceCandidateSyncByFile.delete(file);
+		});
+		pendingSourceCandidateSyncs.add(task);
+		pendingSourceCandidateSyncByFile.set(file, task);
+		return task;
+	};
+	const shouldCollectTransformedSourceCandidates = (id) => {
+		if (id.search(/[?#]/) < 0) return true;
+		const file = cleanUrl(id);
+		return !/\.(?:vue|uvue|nvue|svelte|mpx)$/i.test(file);
+	};
+	const rememberCssSource = (entry, cssRuntimeSignature) => {
+		const key = normalizeOutputPathKey(entry.outputFile);
+		rememberedCssSources.set(key, entry);
+		if (cssRuntimeSignature) rememberedCssSignatureByFile.set(key, cssRuntimeSignature);
+	};
+	const getRememberedCssSources = () => rememberedCssSources;
+	const getRememberedCssSourceEntry = (file) => rememberedCssSources.get(normalizeOutputPathKey(file));
+	const getRememberedCssSignature = (file) => rememberedCssSignatureByFile.get(normalizeOutputPathKey(file));
+	const setRememberedCssSignature = (file, cssRuntimeSignature) => {
+		rememberedCssSignatureByFile.set(normalizeOutputPathKey(file), cssRuntimeSignature);
+	};
+	const recordCssAssetResult = (file, css) => {
+		viteGeneratedCssByFile.set(file, css);
+	};
+	const recordViteProcessedCssAssetResult = (file, css, options = {}) => {
+		viteProcessedCssAssetResults.set(normalizeOutputPathKey(file), {
+			css,
+			injectIntoMain: options.injectIntoMain
+		});
+	};
+	const getViteProcessedCssAssetResults = () => viteProcessedCssAssetResults.entries();
+	const getViteProcessedCssAssetResult = (file) => viteProcessedCssAssetResults.get(normalizeOutputPathKey(file));
+	const normalizeViteProcessedCssFile = (file) => path.resolve(cleanUrl(file));
+	const markViteProcessedCssSource = (file) => {
+		viteProcessedCssSourceFiles.add(normalizeViteProcessedCssFile(file));
+	};
+	const rememberTailwindRootCssModule = (id) => {
+		if (!shouldOwnTailwindGeneration) return;
+		tailwindRootCssModuleIds.add(id);
+		tailwindRootCssModuleIds.add(cleanUrl(id));
+	};
+	const resolveHotTailwindCssModules = (ctx) => {
+		const modules = [];
+		const seenModules = /* @__PURE__ */ new Set();
+		const collectModule = (mod) => {
+			if (mod == null || seenModules.has(mod)) return;
+			if (!isSourceStyleRequest(mod.id ?? mod.url)) return;
+			seenModules.add(mod);
+			ctx.server.moduleGraph.invalidateModule(mod);
+			modules.push(mod);
+		};
+		for (const id of tailwindRootCssModuleIds) {
+			const candidates = [
+				ctx.server.moduleGraph.getModuleById(id),
+				ctx.server.moduleGraph.getModuleById(cleanUrl(id)),
+				...ctx.server.moduleGraph.getModulesByFile(id) ?? [],
+				...ctx.server.moduleGraph.getModulesByFile(cleanUrl(id)) ?? []
+			];
+			for (const mod of candidates) collectModule(mod);
+		}
+		return modules;
+	};
+	const resolveModuleHotUrl = (mod) => {
+		if (typeof mod.url === "string" && mod.url.length > 0) return mod.url;
+		if (typeof mod.id === "string" && mod.id.startsWith("/")) return mod.id;
+	};
+	const includesHotModule = (modules, target) => {
+		const targetUrl = resolveModuleHotUrl(target);
+		const targetId = target.id;
+		return modules.some((mod) => {
+			if (mod === target) return true;
+			return targetUrl !== void 0 && resolveModuleHotUrl(mod) === targetUrl || typeof targetId === "string" && targetId.length > 0 && mod.id === targetId;
+		});
+	};
+	const hasSelfAcceptingNonStyleHotModule = (modules) => {
+		return modules.some((mod) => {
+			return !isSourceStyleRequest(mod.id ?? mod.url) && mod.isSelfAccepting === true;
+		});
+	};
+	const isUniViteProject = () => {
+		return resolvedConfig?.plugins?.some((plugin) => plugin.name.includes("uni")) ?? false;
+	};
+	const sendSupplementalCssHotUpdates = (ctx, cssModules) => {
+		const updates = cssModules.filter((mod) => !includesHotModule(ctx.modules, mod)).map((mod) => {
+			const hotUrl = resolveModuleHotUrl(mod);
+			if (!hotUrl) return;
+			return {
+				type: "js-update",
+				timestamp: ctx.timestamp,
+				path: hotUrl,
+				acceptedPath: hotUrl,
+				explicitImportRequired: false,
+				isWithinCircularImport: false
+			};
+		}).filter((update) => update !== void 0);
+		if (updates.length === 0) return;
+		queueMicrotask(() => {
+			ctx.server.ws?.send?.({
+				type: "update",
+				updates
+			});
+		});
+	};
+	const sendFullReloadForUnresolvedHotUpdate = (ctx) => {
+		ctx.server.ws?.send?.({
+			type: "full-reload",
+			path: "*",
+			triggeredBy: ctx.file
+		});
+	};
+	const matchesViteProcessedCssSource = (candidate) => {
+		const normalized = normalizeViteProcessedCssFile(candidate);
+		return viteProcessedCssSourceFiles.has(normalized);
+	};
+	const isViteProcessedCssAsset = (asset, file) => {
+		if (hasBundlerGeneratedCssMarker(asset.source)) return true;
+		return [
+			file,
+			asset.originalFileName,
+			...asset.originalFileNames ?? []
+		].filter((item) => typeof item === "string" && item.length > 0).some((candidate) => matchesViteProcessedCssSource(cleanUrl(candidate)));
+	};
+	const transformCssHandlerOptions = createCssHandlerOptionsCache({
+		getAppType: () => opts.appType,
+		mainCssChunkMatcher,
+		getMajorVersion: () => runtimeState.twPatcher.majorVersion,
+		getOutputRoot: () => resolvedConfig?.build?.outDir ? path.resolve(resolvedConfig.root, resolvedConfig.build.outDir) : resolvedConfig?.root
+	});
+	const generateTailwindCssForVitePipeline = async (id, code, hookContext) => {
+		if (!shouldOwnTailwindGeneration) return;
+		await runtimeState.readyPromise;
+		await waitForSourceCandidateSyncs();
+		const file = cleanUrl(id);
+		const runtime = getRecordedGeneratorCandidates() ?? getSourceCandidates() ?? await ensureRuntimeClassSet();
+		const cssHandlerOptions = transformCssHandlerOptions.getCssHandlerOptions(file);
+		const generated = await generateCssByGenerator({
+			opts,
+			runtimeState,
+			runtime,
+			rawSource: code,
+			file,
+			cssHandlerOptions,
+			cssUserHandlerOptions: transformCssHandlerOptions.getCssUserHandlerOptions(file),
+			getSourceCandidatesForEntries,
+			styleHandler,
+			debug,
+			previousCss: viteGeneratedCssByFile.get(file),
+			deferEmptyScopedCssSource: true
+		});
+		if (!generated) return;
+		const outputFile = resolveViteCssPipelineOutputFile(file, opts, resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process.cwd(), generatorOptions.target === "web");
+		for (const dependency of generated.dependencies) hookContext?.addWatchFile?.(dependency);
+		viteGeneratedCssByFile.set(file, generated.css);
+		if (generated.css.includes("weapp-tailwindcss layer components start")) recordViteProcessedCssAssetResult(file, generated.css, { injectIntoMain: cssHandlerOptions.isMainChunk });
+		markViteProcessedCssSource(file);
+		rememberTailwindRootCssModule(id);
+		recordGeneratorCandidates(runtime);
+		rememberCssSource({
+			outputFile,
+			rawSource: code,
+			sourceFile: file
+		});
+		debug("css generated for vite postcss pipeline: %s bytes=%d", file, generated.css.length);
+		return `${createBundlerGeneratedCssMarker("vite", normalizeViteProcessedCssFile(file))}\n${generated.css}`;
+	};
+	const rewritePlugins = createRewriteCssImportsPlugins({
+		getAppType: () => opts.appType,
+		generateTailwindCss: generateTailwindCssForVitePipeline,
+		rootImport: shouldOwnTailwindGeneration ? `${weappTailwindcssDirPosix}/generator-placeholder.css` : void 0,
+		onTailwindRootCss: (id, code) => registerAutoCssSource(id, code),
+		shouldOwnTailwindGeneration,
+		shouldRewrite: shouldRewriteCssImports,
+		weappTailwindcssDirPosix
+	});
+	if (disabledOptions.plugin) return rewritePlugins.length ? rewritePlugins : void 0;
+	const generateBundleHook = createGenerateBundleHook({
+		opts,
+		runtimeState,
+		ensureRuntimeClassSet,
+		ensureBundleRuntimeClassSet,
+		debug,
+		getResolvedConfig,
+		markCssAssetProcessed,
+		isCssAssetProcessed,
+		isViteProcessedCssAsset,
+		recordCssAssetResult,
+		recordViteProcessedCssAssetResult,
+		getViteProcessedCssAssetResults,
+		getViteProcessedCssAssetResult,
+		getSourceCandidates,
+		getSourceCandidatesForEntries,
+		waitForSourceCandidateSyncs,
+		rememberCssSource,
+		getRememberedCssSources,
+		getRememberedCssSignature,
+		setRememberedCssSignature,
+		recordGeneratorCandidates,
+		hmrTimingRecorder
+	});
+	const cssFinalizerOutputPlugin = createViteCssFinalizerOutputPlugin({
+		opts,
+		runtimeState,
+		ensureRuntimeClassSet,
+		debug,
+		getResolvedConfig,
+		markCssAssetProcessed,
+		isCssAssetProcessed,
+		isViteProcessedCssAsset,
+		recordCssAssetResult,
+		recordViteProcessedCssAssetResult,
+		getViteProcessedCssAssetResults,
+		getRecordedGeneratorCandidates,
+		getSourceCandidates,
+		getSourceCandidatesForEntries,
+		waitForSourceCandidateSyncs,
+		rememberMainCssSource: (file, rawSource) => rememberCssSource({
+			outputFile: file,
+			rawSource,
+			sourceFile: file
+		}),
+		getRememberedMainCssSource: getRememberedCssSourceEntry
+	});
+	const isIosPlatform = resolveUniUtsPlatform().isAppIos;
+	const prepareTailwindGeneration = async () => {
+		if (shouldDiscoverAutoCssSources()) await discoverAndRegisterAutoCssSources();
+		await syncSourceCandidateScan();
+	};
+	const uniAppXPlugins = uniAppXEnabled ? createUniAppXPlugins({
+		appType: opts.appType ?? "uni-app-x",
+		customAttributesEntities,
+		disabledDefaultTemplateHandler,
+		isIosPlatform,
+		mainCssChunkMatcher,
+		runtimeState,
+		styleHandler,
+		jsHandler,
+		ensureRuntimeClassSet,
+		getResolvedConfig,
+		uniAppX
+	}) : void 0;
+	const plugins = [
+		...rewritePlugins,
+		{
+			name: `${vitePluginName}:source-candidates`,
+			enforce: "pre",
+			async transform(code, id) {
+				if (!shouldOwnTailwindGeneration || !isSourceCandidateRequest(id) || !shouldCollectTransformedSourceCandidates(id)) return;
+				return hmrTimingRecorder.measure("sourceCandidates.transform", async () => {
+					invalidateRecordedGeneratorCandidates();
+					const file = cleanUrl(id);
+					if (sourceScanMatcher && !sourceScanMatcher(file)) {
+						sourceCandidateCollector.remove(file);
+						cacheCurrentSourceCandidateScan();
+						return;
+					}
+					if (sourceScanExplicit && sourceScanEntries?.length === 0) {
+						cacheCurrentSourceCandidateScan();
+						return;
+					}
+					await sourceCandidateCollector.merge(id, code);
+					cacheCurrentSourceCandidateScan();
+				}, { emit: false });
+			},
+			async watchChange(id, change) {
+				await hmrTimingRecorder.measure("sourceCandidates.watchChange", async () => {
+					if (shouldOwnTailwindGeneration && isSourceCandidateRequest(id)) invalidateRecordedGeneratorCandidates();
+					if (isSourceScanDependency(id)) invalidateSourceCandidateScan();
+					if (change.event === "delete") {
+						sourceCandidateCollector.remove(id);
+						cacheCurrentSourceCandidateScan();
+						return;
+					}
+					await syncChangedSourceCandidateFile(id);
+				}, { emit: false });
+			},
+			async handleHotUpdate(ctx) {
+				return hmrTimingRecorder.measure("sourceCandidates.handleHotUpdate", async () => {
+					const isSourceCandidateHotUpdate = shouldOwnTailwindGeneration && isSourceCandidateRequest(ctx.file);
+					await syncChangedSourceCandidateFile(ctx.file);
+					if (isSourceCandidateHotUpdate) invalidateRecordedGeneratorCandidates();
+					const cssModules = resolveHotTailwindCssModules(ctx);
+					if (isSourceCandidateHotUpdate && !isSourceStyleRequest(ctx.file) && (!hasSelfAcceptingNonStyleHotModule(ctx.modules) && cssModules.length === 0 || cssModules.length > 0 && isUniViteProject())) {
+						sendFullReloadForUnresolvedHotUpdate(ctx);
+						return [];
+					}
+					sendSupplementalCssHotUpdates(ctx, cssModules);
+					return cssModules.length > 0 ? [...ctx.modules, ...cssModules] : void 0;
+				}, { emit: false });
+			},
+			async buildStart() {
+				await hmrTimingRecorder.measure("sourceCandidates.buildStart", async () => {
+					await prepareTailwindGeneration();
+				}, { emit: false });
+			}
+		},
+		...createViteServeCssGenerationPlugins({
+			generateCss: generateTailwindCssForVitePipeline,
+			getCommand: () => resolvedConfig?.command,
+			onTailwindRootCss: (id, code) => registerAutoCssSource(id, code),
+			shouldGenerate: () => shouldOwnTailwindGeneration
+		}),
+		{
+			name: `${vitePluginName}:post`,
+			enforce: "post",
+			config(config) {
+				if (!shouldOwnTailwindGeneration) return;
+				if (Array.isArray(config.plugins)) {
+					const removed = disableAndRemoveTailwindVitePlugins(config.plugins);
+					if (removed > 0) debug("disable official tailwind vite plugins in generator mode: %d", removed);
+				}
+				const root = config.root ? path.resolve(config.root) : process.cwd();
+				const baseConfig = { resolve: { alias: [{
+					find: /^tailwindcss$/,
+					replacement: path.join(weappTailwindcssPackageDir, "generator-placeholder.css")
+				}] } };
+				if (config.css?.postcss !== void 0) return baseConfig;
+				return resolveFilteredPostcssConfig(root).then((postcssConfig) => {
+					if (!postcssConfig) return baseConfig;
+					debug("inline filtered postcss config without official tailwind plugins in generator mode: %d", postcssConfig.removed);
+					return {
+						...baseConfig,
+						css: { postcss: {
+							...postcssConfig.options,
+							plugins: postcssConfig.plugins
+						} }
+					};
+				});
+			},
+			async configResolved(config) {
+				await hmrTimingRecorder.measure("configResolved", async () => {
+					resolvedConfig = config;
+					if (shouldOwnTailwindGeneration) {
+						const removed = Array.isArray(config.plugins) ? removeTailwindVitePlugins(config.plugins) : 0;
+						if (removed > 0) debug("remove official tailwind vite plugins in generator mode: %d", removed);
+					}
+					const resolvedRoot = config.root ? path.resolve(config.root) : void 0;
+					let shouldRefreshRuntime = false;
+					if (!hasExplicitTailwindcssBasedir && resolvedRoot) {
+						const nextTailwindcssBasedir = resolveImplicitTailwindcssBasedirFromViteRoot(resolvedRoot);
+						if (opts.tailwindcssBasedir !== nextTailwindcssBasedir) {
+							const previousBasedir = opts.tailwindcssBasedir;
+							opts.tailwindcssBasedir = nextTailwindcssBasedir;
+							debug("align tailwindcss basedir with vite root: %s -> %s", previousBasedir ?? "undefined", nextTailwindcssBasedir);
+							shouldRefreshRuntime = true;
+						}
+					}
+					if (shouldInferAppType && resolvedRoot) {
+						const nextAppType = resolveImplicitAppTypeFromViteRoot(resolvedRoot);
+						if (nextAppType && opts.appType !== nextAppType) {
+							const previousAppType = opts.appType;
+							opts.appType = nextAppType;
+							logger.info("根据 Vite 项目根目录自动推断 appType -> %s", nextAppType);
+							debug("align appType with vite root: %s -> %s", previousAppType ?? "undefined", nextAppType);
+							shouldRefreshRuntime = true;
+						}
+					}
+					if (shouldRefreshRuntime) await refreshRuntimeState(true);
+					if (typeof config.css.postcss === "object" && Array.isArray(config.css.postcss.plugins)) {
+						const postcssPlugins = config.css.postcss.plugins;
+						if (shouldOwnTailwindGeneration) {
+							const removed = removeTailwindPostcssPlugins(postcssPlugins);
+							if (removed > 0) debug("remove official tailwind postcss plugins in generator mode: %d", removed);
+						}
+						const idx = postcssPlugins.findIndex((x) => getPostcssPluginName(x) === "postcss-html-transform");
+						if (idx > -1) {
+							postcssPlugins.splice(idx, 1, postcssHtmlTransform());
+							debug("remove postcss-html-transform plugin from vite config");
+						}
+					}
+				}, { emit: false });
+			},
+			generateBundle: generateBundleHook
+		},
+		cssFinalizerOutputPlugin
+	];
+	if (uniAppXPlugins) plugins.push(...uniAppXPlugins);
+	return plugins;
+}
+//#endregion
+export { WeappTailwindcss as t };