weapp-tailwindcss 5.0.3 → 5.0.5

package/dist/vite-DLXDMHON.mjs

@@ -0,0 +1,3270 @@
+import { C as hasLocalCssImport, D as normalizeTailwindConfigDirectives, E as hasTailwindSourceDirectives, L as hasTailwindGeneratedCssMarkers, M as removeTailwindSourceDirectives, T as hasTailwindRootDirectives, Y as filterUnsupportedMiniProgramTailwindV4Candidates, _ as resolveViteSourceScanEntries, _t as findNearestPackageRoot, ft as findTailwindConfig, g as resolveTailwindV4EntriesFromCssCached, gt as omitUndefined, j as parseImportRequest, k as normalizeTailwindSourceForGenerator, l as getRuntimeClassSetSignature, lt as createDebug, m as discoverTailwindV4CssEntries, p as createViteSourceScanMatcher, pt as resolveTailwindcssOptions, st as resolveTailwindV4CssSourceBase, v as resolveViteTailwindV4CssDependencies, w as hasTailwindApplyDirective } from "./v3-engine-Cczrkzqt.mjs";
+import { i as normalizeWeappTailwindcssGeneratorOptions } from "./generator-DVWLNO0n.mjs";
+import { _ as collectRuntimeClassSet, a as vitePluginName, b as refreshTailwindRuntimeState, g as toCustomAttributesEntities, n as getCompilerContext, t as shouldSkipJsTransform, v as createTailwindRuntimeReadyPromise } from "./precheck-Bsn_LMmo.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-AWaPVF2B.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-xf49kky6.mjs";
+import { n as createTailwindV3DefaultExtractor, r as isSourceCandidateRequest, t as createSourceCandidateCollector } from "./source-candidates-BsWYoIPN.mjs";
+import { C as toAbsoluteOutputPath, _ as normalizePath, a as applyLinkedResults, b as stripRequestQuery, 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 slash, x as normalizeOutputPathKey, y as isSourceStyleRequest } from "./bundle-state-DEyxCR4f.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$1 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-DumSZmTh.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)$/;
+const CSS_MODULE_EXPORT_RE = /^\s*export\s+default\s+(?:\{|\w|\[\])/;
+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 isCssModuleExport(code) {
+	return CSS_MODULE_EXPORT_RE.test(code);
+}
+function createUniAppXPlugins(options) {
+	const { appType, customAttributesEntities, disabledDefaultTemplateHandler, isIosPlatform: providedIosPlatform, mainCssChunkMatcher, runtimeState, styleHandler, generateCss, 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, hookContext) {
+		const parsed = query ?? parseVueRequest(id).query;
+		if (isCSSRequest(id) || parsed.vue && parsed.type === "style") {
+			if (isCssModuleExport(code)) return;
+			const generatedCss = hasTailwindSourceDirectives(code, { importFallback: true }) || hasTailwindApplyDirective(code) ? await generateCss?.(id, code, hookContext) : void 0;
+			const styleCode = typeof generatedCss === "string" && generatedCss.trim().length > 0 ? generatedCss : code;
+			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(styleCode, 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(), normalizePath(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, void 0, this);
+		}
+	}, {
+		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, this);
+		}
+	}];
+	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 extraOptions = options.getExtraOptions?.(file) ?? {};
+		const cacheKey = `${majorVersion ?? "unknown"}:${appType ?? "unknown"}:${isMainChunk ? "1" : "0"}:${outputRoot ?? ""}:${file}:${JSON.stringify(extraOptions)}`;
+		const cached = cssHandlerOptionsCache.get(cacheKey);
+		if (cached) return cached;
+		const created = {
+			...extraOptions,
+			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 ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+let _lazyMatch = () => {
+	var __lib__ = (() => {
+		var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r, e) => {
+			for (var n in e) m(r, n, {
+				get: e[n],
+				enumerable: true
+			});
+		}, H = (r, e, n, a) => {
+			if (e && typeof e == "object" || typeof e == "function") for (let t of G(e)) !T.call(r, t) && t !== n && m(r, t, {
+				get: () => e[t],
+				enumerable: !(a = V(e, t)) || a.enumerable
+			});
+			return r;
+		}, J = (r) => H(m({}, "__esModule", { value: true }), r), w = {};
+		q(w, { default: () => re });
+		var A = (r) => Array.isArray(r), d = (r) => typeof r == "function", Q = (r) => r.length === 0, W = (r) => typeof r == "number", K = (r) => typeof r == "object" && r !== null, X = (r) => r instanceof RegExp, b = (r) => typeof r == "string", h = (r) => r === void 0, Y = (r) => {
+			const e = /* @__PURE__ */ new Map();
+			return (n) => {
+				const a = e.get(n);
+				if (a) return a;
+				const t = r(n);
+				return e.set(n, t), t;
+			};
+		}, rr = (r, e, n = {}) => {
+			const a = {
+				cache: {},
+				input: r,
+				index: 0,
+				indexMax: 0,
+				options: n,
+				output: []
+			};
+			if (v(e)(a) && a.index === r.length) return a.output;
+			throw new Error(`Failed to parse at index ${a.indexMax}`);
+		}, i = (r, e) => A(r) ? er(r, e) : b(r) ? ar(r, e) : nr(r, e), er = (r, e) => {
+			const n = {};
+			for (const a of r) {
+				if (a.length !== 1) throw new Error(`Invalid character: "${a}"`);
+				const t = a.charCodeAt(0);
+				n[t] = true;
+			}
+			return (a) => {
+				const t = a.index, o = a.input;
+				for (; a.index < o.length && o.charCodeAt(a.index) in n;) a.index += 1;
+				const u = a.index;
+				if (u > t) {
+					if (!h(e) && !a.options.silent) {
+						const s = a.input.slice(t, u), c = d(e) ? e(s, o, String(t)) : e;
+						h(c) || a.output.push(c);
+					}
+					a.indexMax = Math.max(a.indexMax, a.index);
+				}
+				return true;
+			};
+		}, nr = (r, e) => {
+			const n = r.source, a = r.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
+			return g((o) => {
+				t.lastIndex = o.index;
+				const u = t.exec(o.input);
+				if (u) {
+					if (!h(e) && !o.options.silent) {
+						const s = d(e) ? e(...u, o.input, String(o.index)) : e;
+						h(s) || o.output.push(s);
+					}
+					return o.index += u[0].length, o.indexMax = Math.max(o.indexMax, o.index), true;
+				} else return false;
+			});
+		}, ar = (r, e) => (n) => {
+			if (n.input.startsWith(r, n.index)) {
+				if (!h(e) && !n.options.silent) {
+					const t = d(e) ? e(r, n.input, String(n.index)) : e;
+					h(t) || n.output.push(t);
+				}
+				return n.index += r.length, n.indexMax = Math.max(n.indexMax, n.index), true;
+			} else return false;
+		}, C = (r, e, n, a) => {
+			const t = v(r);
+			return g(_(M((o) => {
+				let u = 0;
+				for (; u < n;) {
+					const s = o.index;
+					if (!t(o) || (u += 1, o.index === s)) break;
+				}
+				return u >= e;
+			})));
+		}, tr = (r, e) => C(r, 0, 1), f = (r, e) => C(r, 0, Infinity), x = (r, e) => {
+			const n = r.map(v);
+			return g(_(M((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (!n[t](a)) return false;
+				return true;
+			})));
+		}, l = (r, e) => {
+			const n = r.map(v);
+			return g(_((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (n[t](a)) return true;
+				return false;
+			}));
+		}, M = (r, e = false) => {
+			const n = v(r);
+			return (a) => {
+				const t = a.index, o = a.output.length, u = n(a);
+				return (!u || e) && (a.index = t, a.output.length !== o && (a.output.length = o)), u;
+			};
+		}, _ = (r, e) => {
+			return v(r);
+		}, g = (() => {
+			let r = 0;
+			return (e) => {
+				const n = v(e), a = r += 1;
+				return (t) => {
+					var o;
+					if (t.options.memoization === false) return n(t);
+					const u = t.index, s = (o = t.cache)[a] || (o[a] = /* @__PURE__ */ new Map()), c = s.get(u);
+					if (c === false) return false;
+					if (W(c)) return t.index = c, true;
+					if (c) return t.index = c.index, c.output?.length && t.output.push(...c.output), true;
+					{
+						const Z = t.output.length;
+						if (n(t)) {
+							const D = t.index, U = t.output.length;
+							if (U > Z) {
+								const ee = t.output.slice(Z, U);
+								s.set(u, {
+									index: D,
+									output: ee
+								});
+							} else s.set(u, D);
+							return true;
+						} else return s.set(u, false), false;
+					}
+				};
+			};
+		})(), E = (r) => {
+			let e;
+			return (n) => (e || (e = v(r())), e(n));
+		}, v = Y((r) => {
+			if (d(r)) return Q(r) ? E(r) : r;
+			if (b(r) || X(r)) return i(r);
+			if (A(r)) return x(r);
+			if (K(r)) return l(Object.values(r));
+			throw new Error("Invalid rule");
+		}), P = "abcdefghijklmnopqrstuvwxyz", ir = (r) => {
+			let e = "";
+			for (; r > 0;) e = P[(r - 1) % 26] + e, r = Math.floor((r - 1) / 26);
+			return e;
+		}, O = (r) => {
+			let e = 0;
+			for (let n = 0, a = r.length; n < a; n++) e = e * 26 + P.indexOf(r[n]) + 1;
+			return e;
+		}, S = (r, e) => {
+			if (e < r) return S(e, r);
+			const n = [];
+			for (; r <= e;) n.push(r++);
+			return n;
+		}, or = (r, e, n) => S(r, e).map((a) => String(a).padStart(n, "0")), R = (r, e) => S(O(r), O(e)).map(ir), p = (r) => r, z = (r) => ur((e) => rr(e, r, { memoization: false }).join("")), ur = (r) => {
+			const e = {};
+			return (n) => e[n] ?? (e[n] = r(n));
+		}, sr = i(/^\*\*\/\*$/, ".*"), cr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r, e, n) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r, e, n, a) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i(/\\./, p), pr = i(/[$.*+?^(){}[\]\|]/, (r) => `\\${r}`), vr = i(/./, p), fr = l([i(/^(?:!!)*!(.*)$/, (r, e) => `(?!^${L(e)}$).*?`), i(/^(!!)+/, "")]), j = l([
+			i(/\/(\*\*\/)+/, "(?:/.+/|/)"),
+			i(/^(\*\*\/)+/, "(?:^|.*/)"),
+			i(/\/(\*\*)$/, "(?:/.*|$)"),
+			i(/\*\*/, ".*")
+		]), N = l([i(/\*\/(?!\*\*\/)/, "[^/]*/"), i(/\*/, "[^/]*")]), k = i("?", "[^/]"), $r = i("[", p), wr = i("]", p), Ar = i(/[!^]/, "^/"), br = i(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Er = l([
+			y,
+			i(/[$.*+?^(){}[\|]/, (r) => `\\${r}`),
+			br,
+			i(/[^\]]/, p)
+		]), B = x([
+			$r,
+			tr(Ar),
+			f(Er),
+			wr
+		]), Pr = i("{", "(?:"), Or = i("}", ")"), I = x([
+			Pr,
+			l([
+				i(/(\d+)\.\.(\d+)/, (r, e, n) => or(+e, +n, Math.min(e.length, n.length)).join("|")),
+				i(/([a-z]+)\.\.([a-z]+)/, (r, e, n) => R(e, n).join("|")),
+				i(/([A-Z]+)\.\.([A-Z]+)/, (r, e, n) => R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase())
+			]),
+			Or
+		]), kr = i("{", "(?:"), Br = i("}", ")"), Ir = i(",", "|"), Fr = i(/[$.*+?^(){[\]\|]/, (r) => `\\${r}`), Lr = i(/[^}]/, p), F = x([
+			kr,
+			f(l([
+				j,
+				N,
+				k,
+				B,
+				I,
+				E(() => F),
+				y,
+				Fr,
+				Ir,
+				Lr
+			])),
+			Br
+		]), L = z(f(l([
+			sr,
+			cr,
+			lr,
+			fr,
+			j,
+			N,
+			k,
+			B,
+			I,
+			F,
+			y,
+			pr,
+			vr
+		]))), Tr = i(/\\./, p), qr = i(/./, p), Yr = z(f(l([
+			Tr,
+			i(/\*\*\*+/, "*"),
+			i(/([^/{[(!])\*\*/, (r, e) => `${e}*`),
+			i(/(^|.)\*\*(?=[^*/)\]}])/, (r, e) => `${e}*`),
+			qr
+		]))), $ = (r, e) => {
+			const n = Array.isArray(r) ? r : [r];
+			if (!n.length) return false;
+			const a = n.map($.compile), t = n.every((s) => /(\/(?:\*\*)?|\[\/\])$/.test(s)), o = e.replace(/[\\\/]+/g, "/").replace(/\/$/, t ? "/" : "");
+			return a.some((s) => s.test(o));
+		};
+		$.compile = (r) => new RegExp(`^${L(Yr(r))}$`, "s");
+		var re = $;
+		return J(w);
+	})();
+	return __lib__.default || __lib__;
+};
+let _match;
+const zeptomatch = (path, pattern) => {
+	if (!_match) {
+		_match = _lazyMatch();
+		_lazyMatch = null;
+	}
+	return _match(path, pattern);
+};
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+	return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const format = function(p) {
+	const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
+	const segments = [
+		p.root,
+		p.dir,
+		p.base ?? (p.name ?? "") + ext
+	].filter(Boolean);
+	return normalizeWindowsPath(p.root ? resolve(...segments) : segments.join("/"));
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+const parse$1 = function(p) {
+	const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+	const base = basename(p);
+	const extension = extname(base);
+	return {
+		root,
+		dir: dirname(p),
+		base,
+		ext: extension,
+		name: base.slice(0, base.length - extension.length)
+	};
+};
+const matchesGlob = (path, pattern) => {
+	return zeptomatch(pattern, normalize(path));
+};
+const _path = {
+	__proto__: null,
+	basename,
+	dirname,
+	extname,
+	format,
+	isAbsolute,
+	join,
+	matchesGlob,
+	normalize,
+	normalizeString,
+	parse: parse$1,
+	relative,
+	resolve,
+	sep: "/",
+	toNamespacedPath
+};
+//#endregion
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs
+const delimiter = /* @__PURE__ */ (() => globalThis.process?.platform === "win32" ? ";" : ":")();
+const _platforms = {
+	posix: void 0,
+	win32: void 0
+};
+const mix = (del = delimiter) => {
+	return new Proxy(_path, { get(_, prop) {
+		if (prop === "delimiter") return del;
+		if (prop === "posix") return posix;
+		if (prop === "win32") return win32;
+		return _platforms[prop] || _path[prop];
+	} });
+};
+const posix = /* @__PURE__ */ mix(":");
+const win32 = /* @__PURE__ */ mix(";");
+//#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 removeTailwindSourceMediaWrappers(css) {
+	if (!css.includes("@media source(")) return css;
+	try {
+		const root = postcss.parse(css);
+		let changed = false;
+		root.walkAtRules("media", (atRule) => {
+			if (!atRule.params.startsWith("source(")) return;
+			if (atRule.nodes && atRule.nodes.length > 0) atRule.replaceWith(...atRule.nodes);
+			else atRule.remove();
+			changed = true;
+		});
+		root.walkAtRules((atRule) => {
+			if (atRule.nodes && atRule.nodes.length === 0) {
+				atRule.remove();
+				changed = true;
+			}
+		});
+		return changed ? root.toString() : css;
+	} catch {
+		return css.replace(/@media\s+source\([^)]*\)\s*\{\s*\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\/?\s*\}/gi, "").replace(/@media\s+source\([^)]*\)\s*\{\s*\}/gi, "");
+	}
+}
+function removeTailwindEntryDirectivesFromCss(css) {
+	return removeTailwindSourceDirectives(removeTailwindSourceMediaWrappers(css));
+}
+function stripStyleExtension(file) {
+	return file.replace(/[?#].*$/, "").replace(/\.(?:css|wxss|acss|ttss|qss|jxss|tyss|scss|sass|less|styl|stylus|pcss|postcss)$/i, "");
+}
+function isStyleImportRequest(request) {
+	return typeof request === "string" && request.length > 0 && !/^(?:https?:)?\/\//i.test(request) && /\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i.test(request);
+}
+function resolveImportedStyleFile(targetFile, request) {
+	if (!isStyleImportRequest(request)) return;
+	const cleanRequest = request.replace(/[?#].*$/, "");
+	if (cleanRequest.startsWith("/")) return normalizeOutputPathKey(cleanRequest.slice(1));
+	const targetDir = posix.posix.dirname(normalizeOutputPathKey(targetFile));
+	return normalizeOutputPathKey(posix.posix.join(targetDir === "." ? "" : targetDir, cleanRequest));
+}
+function collectImportedStyleFiles(css, targetFile) {
+	const imports = /* @__PURE__ */ new Set();
+	try {
+		postcss.parse(css).walkAtRules("import", (atRule) => {
+			const importedFile = resolveImportedStyleFile(targetFile, parseImportRequest(atRule.params));
+			if (importedFile) imports.add(importedFile);
+		});
+	} catch {}
+	return imports;
+}
+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;
+	if (options.injectIntoMain === false) return false;
+	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);
+		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 = removeTailwindEntryDirectivesFromCss(originalSource);
+		const importedStyleFiles = collectImportedStyleFiles(nextCss, file);
+		for (const record of viteCssResults) {
+			if (!shouldInjectViteProcessedCssResult(options.opts, mainFileKey, record.file, record)) continue;
+			if (importedStyleFiles.has(normalizeOutputPathKey(record.file))) 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/uni-app-x-css-options.ts
+function resolveUniAppXNativeCssHandlerOptions(opts) {
+	if (opts.appType !== "uni-app-x" || !isUniAppXEnabled(opts.uniAppX) || !resolveUniUtsPlatform().isApp) return {};
+	return {
+		uniAppX: true,
+		uniAppXCssTarget: "uvue",
+		uniAppXUnsupported: resolveUniAppXOptions(opts.uniAppX).uvueUnsupported
+	};
+}
+//#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, preserveCssExtension = false) {
+	const normalizedFile = resolveReplayCssOutputFile(rootDir, file);
+	if (isWebGeneratorTarget || preserveCssExtension || 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 isMainAppCssFile(file) {
+	return path.basename(stripStyleFileExtension(file)) === "app";
+}
+function normalizeCssSourceForCompare(css) {
+	return css.trim();
+}
+function createRememberedCssRuntimeSignature(cssRuntimeSignature, cssRuntimeAffectingHash) {
+	return `${cssRuntimeSignature}:${cssRuntimeAffectingHash}`;
+}
+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) {
+	return scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) > 0;
+}
+function scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	const outputBases = collectStyleFileMatchBases(outputFile, [outputRoot]);
+	const sourceBases = collectStyleFileMatchBases(sourceFile, [sourceRoot, ...collectParentDirectories(sourceFile)]);
+	let bestScore = 0;
+	for (const outputBase of outputBases) for (const sourceBase of sourceBases) if (outputBase === sourceBase) bestScore = Math.max(bestScore, 1e5 + outputBase.length);
+	else if (outputBase.endsWith(`/${sourceBase}`)) bestScore = Math.max(bestScore, 5e4 + sourceBase.length);
+	else if (sourceBase.endsWith(`/${outputBase}`)) bestScore = Math.max(bestScore, 1e3 + outputBase.length);
+	return bestScore;
+}
+function findRememberedCssSource(sources, outputFile, file, originalSource, outputRoot, sourceRoot) {
+	if (!sources) return;
+	const rememberedSources = [...sources].map(([, remembered]) => remembered);
+	const originalFiles = [
+		file,
+		originalSource.originalFileName,
+		...originalSource.originalFileNames ?? []
+	].filter((item) => typeof item === "string" && item.length > 0);
+	const sourceMatched = rememberedSources.find((remembered) => originalFiles.some((originalFile) => normalizeOutputPathKey(remembered.sourceFile) === normalizeOutputPathKey(originalFile)));
+	if (sourceMatched) return sourceMatched;
+	const outputMatched = rememberedSources.find((remembered) => normalizeOutputPathKey(remembered.outputFile) === normalizeOutputPathKey(outputFile));
+	if (outputMatched) return outputMatched;
+	const scoredMatches = rememberedSources.filter((remembered) => !(isMainAppCssFile(outputFile) && isAppOriginCssFile(remembered.outputFile))).map((remembered) => ({
+		remembered,
+		score: Math.max(scoreMatchingStyleFileBase(outputFile, remembered.sourceFile, outputRoot, sourceRoot), scoreMatchingStyleFileBase(outputFile, remembered.outputFile, outputRoot, sourceRoot))
+	})).filter((match) => match.score > 0).sort((a, b) => b.score - a.score);
+	const bestScore = scoredMatches[0]?.score;
+	return bestScore && scoredMatches.filter((match) => match.score === bestScore).length === 1 ? scoredMatches[0]?.remembered : void 0;
+}
+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,
+		getExtraOptions: () => resolveUniAppXNativeCssHandlerOptions(context.opts)
+	});
+	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, refreshRememberedCssSource, 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 isNativeAppStyleTarget = resolveUniUtsPlatform().isApp;
+		const shouldGenerateWebCssByGenerator = isWebGeneratorTarget && runtimeState.twPatcher.majorVersion === 3;
+		const { getCssHandlerOptions, getCssUserHandlerOptions } = cssHandlerOptions;
+		const resolvedConfig = getResolvedConfig();
+		const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process$1.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, isNativeAppStyleTarget),
+			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$1.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1";
+		const disableDirtyOptimization = process$1.env["WEAPP_TW_VITE_DISABLE_DIRTY"] === "1";
+		const disableJsPrecheck = process$1.env["WEAPP_TW_VITE_DISABLE_JS_PRECHECK"] === "1";
+		const debugCssDiff = process$1.env["WEAPP_TW_VITE_DEBUG_CSS_DIFF"] === "1";
+		const disableV3OxideSourceRuntime = process$1.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;
+				let rememberedCssSource = findRememberedCssSource(getRememberedCssSources?.(), outputFile, file, originalSource, outDir, opts.tailwindcssBasedir);
+				if (rememberedCssSource != null) rememberedCssSource = await refreshRememberedCssSource?.(rememberedCssSource) ?? rememberedCssSource;
+				const useRememberedCssSource = rememberedCssSource != null && normalizeOutputPathKey(rememberedCssSource.sourceFile) !== normalizeOutputPathKey(file);
+				const vitePipelineCssAsset = viteProcessedCssAsset || useRememberedCssSource;
+				const generatorRawSource = vitePipelineCssAsset ? rememberedCssSource?.rawSource ?? rawSource : rawSource;
+				const hasRememberedApplySource = vitePipelineCssAsset && rememberedCssSource != null && hasTailwindApplyDirective(generatorRawSource);
+				const hasDifferentRememberedCssSource = rememberedCssSource != null && normalizeCssSourceForCompare(rememberedCssSource.rawSource) !== normalizeCssSourceForCompare(rawSource);
+				const hasCurrentTailwindGenerationDirective = hasTailwindRootDirectives(rawSource, { importFallback: true }) || hasTailwindApplyDirective(rawSource);
+				const hasRememberedApplyDirective = rememberedCssSource != null && hasTailwindApplyDirective(rememberedCssSource.rawSource);
+				const hasStaleViteProcessedCssSource = vitePipelineCssAsset && hasDifferentRememberedCssSource && (hasCurrentTailwindGenerationDirective || hasRememberedApplyDirective);
+				const generatorSourceFile = vitePipelineCssAsset ? rememberedCssSource?.sourceFile ?? file : file;
+				const outputCssHandlerOptions = getCssHandlerOptions(outputFile);
+				const cssHandlerOptions = vitePipelineCssAsset ? {
+					...getCssHandlerOptions(generatorSourceFile),
+					isMainChunk: outputCssHandlerOptions.isMainChunk || isAppOriginCssFile(file)
+				} : getCssHandlerOptions(file);
+				const generatorCssUserHandlerOptions = getCssUserHandlerOptions(generatorSourceFile);
+				const cssRuntimeAffectingSignature = vitePipelineCssAsset ? createRuntimeAffectingSourceSignature(generatorRawSource, "css") : snapshot.runtimeAffectingSignatureByFile.get(file) ?? createRuntimeAffectingSourceSignature(generatorRawSource, "css");
+				const cssRuntimeAffectingHash = vitePipelineCssAsset ? cache.computeHash(cssRuntimeAffectingSignature) : snapshot.runtimeAffectingHashByFile.get(file) ?? cache.computeHash(cssRuntimeAffectingSignature);
+				const cssShareScope = createCssTransformShareScopeKey(opts, generatorSourceFile, generatorRawSource);
+				const shouldRegenerateAppOriginCss = viteProcessedCssAsset && isAppOriginCssFile(file);
+				const shouldTrackGeneratorRuntime = hasStaleViteProcessedCssSource || shouldProcessTailwindGeneration && (!useIncrementalMode || cssHandlerOptions.isMainChunk || processFiles.css.has(file) || runtimeLinkedCssFiles.has(file) || shouldRegenerateAppOriginCss);
+				const canRegenerateProcessedMainCss = cssHandlerOptions.isMainChunk && (getViteProcessedCssAssetResult?.(file)?.injectIntoMain === true || shouldRegenerateAppOriginCss);
+				if (alreadyProcessedCssAsset && !hasStaleViteProcessedCssSource && !hasRememberedApplySource && (!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 rememberedCssRuntimeSignature = createRememberedCssRuntimeSignature(cssRuntimeSignature, cssRuntimeAffectingHash);
+				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: `${cssRuntimeAffectingHash}:${scopedGeneratorCandidateSignature}`,
+					applyResult(source) {
+						applyCssResult(source);
+						lastCssResultByFile.set(outputFile, source);
+						markCssAssetProcessed?.(originalSource, outputFile);
+						rememberCssSource?.({
+							outputFile,
+							rawSource: generatorRawSource,
+							sourceFile: generatorSourceFile
+						}, rememberedCssRuntimeSignature);
+					},
+					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 = !vitePipelineCssAsset && 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 (vitePipelineCssAsset && cssHandlerOptions.isMainChunk) recordViteProcessedCssAssetResult?.(file, generated.css, { injectIntoMain: !isAppOriginCssFile(file) });
+								if (vitePipelineCssAsset) recordViteProcessedCssAssetResult?.(outputFile, generated.css, { injectIntoMain: false });
+								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(generatorRawSource, cssHandlerOptions);
+							if (debugCssDiff) debug("css diff %s: %s", generatorSourceFile, summarizeStringDiff(generatorRawSource, 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 || isNativeAppStyleTarget) for (const [key, rememberedEntry] of getRememberedCssSources?.() ?? []) {
+			const { outputFile: rememberedOutputFile, rawSource, sourceFile } = await refreshRememberedCssSource?.(rememberedEntry) ?? rememberedEntry;
+			const outputFile = resolveViteCssPipelineOutputFile(rememberedOutputFile, opts, rootDir, isWebGeneratorTarget, isNativeAppStyleTarget);
+			const cssHandlerOptions = getCssHandlerOptions(outputFile);
+			const rememberedCssRuntimeSignature = createRememberedCssRuntimeSignature(createCssRuntimeSignature(runtimeSignature, await createScopedGeneratorCandidateSignature(rawSource, sourceFile, generatorCandidateSignature, getSourceCandidatesForEntries, { includeFallbackSignature: cssHandlerOptions.isMainChunk })), cache.computeHash(createRuntimeAffectingSourceSignature(rawSource, "css")));
+			if (bundleFiles.includes(outputFile) || bundleFiles.includes(sourceFile) || getRememberedCssSignature?.(key) === rememberedCssRuntimeSignature) 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(outputFile),
+					getSourceCandidatesForEntries,
+					styleHandler,
+					debug
+				});
+				const css = generated?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
+				setRememberedCssSignature?.(key, rememberedCssRuntimeSignature);
+				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 {
+		...resolveUniAppXNativeCssHandlerOptions(opts),
+		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 (hasLocalCssImport(rawSource)) return false;
+	if (hasTailwindGeneratedCssMarkers(rawSource)) return true;
+	if (hasTailwindRootDirectives(rawSource, { importFallback: generatorOptions.importFallback })) return true;
+	if (opts.twPatcher.majorVersion === 3) return false;
+	return processed && hasTailwindApplyDirective(rawSource) && 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 isNativeAppStyleTarget = resolveUniUtsPlatform().isApp;
+				const rootDir = resolvedConfig.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
+				collectViteProcessedCssAssetResults(bundle, {
+					opts,
+					isViteProcessedCssAsset,
+					markCssAssetProcessed,
+					recordCssAssetResult,
+					recordViteProcessedCssAssetResult,
+					resolveViteProcessedCssOutputFile: (file) => resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget, isNativeAppStyleTarget),
+					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;
+			await options.onCssSourceTransform?.(id, normalizedCode);
+			const hasTailwindRoot = hasTailwindRootDirectives(normalizedCode);
+			if (hasTailwindRoot) await options.onTailwindRootCss?.(id, normalizedCode);
+			if (options.shouldOwnTailwindGeneration && (hasTailwindRoot || options.shouldGenerateCss?.(id, normalizedCode))) {
+				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
+			};
+		}
+	}];
+}
+function hasVitePipelineTailwindGenerationDirective(code) {
+	return hasTailwindRootDirectives(code) || hasTailwindApplyDirective(code);
+}
+//#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$1.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$1.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();
+const SFC_STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+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
+	});
+}
+function stripSourceHash(sourceFile) {
+	const hashIndex = sourceFile.indexOf("#");
+	return hashIndex === -1 ? sourceFile : sourceFile.slice(0, hashIndex);
+}
+function normalizeCssSourceIdentity(sourceFile) {
+	const cleanSourceFile = stripSourceHash(sourceFile);
+	const { filename, query } = parseVueRequest(cleanSourceFile);
+	const normalizedFile = normalizeOutputPathKey(filename);
+	if (query.type === "style") return `${normalizedFile}?type=style&index=${query.index ?? 0}`;
+	return normalizeOutputPathKey(stripRequestQuery(cleanSourceFile));
+}
+/**
+* @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$1.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$1.env["WEAPP_TW_WATCH_REGRESSION"] === "1" || process$1.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$1.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);
+		const refreshRememberedCssSourceTask = refreshRememberedCssSourceByCurrentFile(file);
+		if (isSourceScanDependency(file)) invalidateSourceCandidateScan();
+		if (sourceScanMatcher && !sourceScanMatcher(file)) {
+			sourceCandidateCollector.remove(file);
+			cacheCurrentSourceCandidateScan();
+			return refreshRememberedCssSourceTask;
+		}
+		if (sourceScanExplicit && sourceScanEntries?.length === 0) {
+			cacheCurrentSourceCandidateScan();
+			return refreshRememberedCssSourceTask;
+		}
+		const existingTask = pendingSourceCandidateSyncByFile.get(file);
+		if (existingTask) return Promise.all([refreshRememberedCssSourceTask, existingTask]).then(() => void 0);
+		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 Promise.all([refreshRememberedCssSourceTask, task]).then(() => void 0);
+	};
+	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);
+		const previous = rememberedCssSources.get(key);
+		rememberedCssSources.set(key, entry);
+		const normalizedSourceFile = normalizeCssSourceIdentity(entry.sourceFile);
+		for (const [rememberedKey, remembered] of rememberedCssSources) {
+			if (rememberedKey === key || normalizeCssSourceIdentity(remembered.sourceFile) !== normalizedSourceFile) continue;
+			rememberedCssSources.set(rememberedKey, {
+				...remembered,
+				rawSource: entry.rawSource,
+				sourceFile: entry.sourceFile
+			});
+			rememberedCssSignatureByFile.delete(rememberedKey);
+		}
+		if (cssRuntimeSignature) rememberedCssSignatureByFile.set(key, cssRuntimeSignature);
+		else if (previous?.rawSource !== entry.rawSource || previous?.sourceFile !== entry.sourceFile) rememberedCssSignatureByFile.delete(key);
+	};
+	const refreshRememberedCssSourceEntry = (rememberedKey, remembered, sourceFile, rawSource) => {
+		if (remembered.rawSource === rawSource && remembered.sourceFile === sourceFile) return remembered;
+		const nextRemembered = {
+			...remembered,
+			rawSource,
+			sourceFile
+		};
+		rememberedCssSources.set(rememberedKey, nextRemembered);
+		rememberedCssSignatureByFile.delete(rememberedKey);
+		return nextRemembered;
+	};
+	const refreshRememberedCssSourceBySourceFile = (sourceFile, rawSource) => {
+		const normalizedSourceFile = normalizeCssSourceIdentity(sourceFile);
+		for (const [rememberedKey, remembered] of rememberedCssSources) {
+			if (normalizeCssSourceIdentity(remembered.sourceFile) !== normalizedSourceFile) continue;
+			refreshRememberedCssSourceEntry(rememberedKey, remembered, sourceFile, rawSource);
+		}
+	};
+	const extractSfcStyleBlock = (source, index) => {
+		const targetIndex = index ?? 0;
+		SFC_STYLE_BLOCK_RE.lastIndex = 0;
+		let currentIndex = 0;
+		let match = SFC_STYLE_BLOCK_RE.exec(source);
+		while (match !== null) {
+			if (currentIndex === targetIndex) return match[1] ?? "";
+			currentIndex++;
+			match = SFC_STYLE_BLOCK_RE.exec(source);
+		}
+	};
+	const refreshRememberedCssSourceByCurrentFile = async (sourceFile) => {
+		const file = cleanUrl(sourceFile);
+		const normalizedSourceFile = normalizeOutputPathKey(file);
+		const matchedRememberedSources = [...rememberedCssSources.values()].filter((remembered) => normalizeOutputPathKey(stripRequestQuery(cleanUrl(remembered.sourceFile))) === normalizedSourceFile);
+		if (matchedRememberedSources.length === 0) return;
+		try {
+			const source = await readFile(file, "utf8");
+			if (/\.(?:vue|uvue|nvue|svelte|mpx)$/i.test(file)) {
+				for (const remembered of matchedRememberedSources) {
+					const { query } = parseVueRequest(remembered.sourceFile);
+					const styleSource = extractSfcStyleBlock(source, query.type === "style" ? query.index : void 0);
+					if (styleSource !== void 0) refreshRememberedCssSourceBySourceFile(remembered.sourceFile, styleSource);
+				}
+				return;
+			}
+			if (isSourceStyleRequest(file)) refreshRememberedCssSourceBySourceFile(file, source);
+		} catch (error) {
+			debug("refresh remembered css source failed: %s %O", file, error);
+		}
+	};
+	const refreshRememberedCssSource = async (remembered) => {
+		const file = cleanUrl(stripRequestQuery(remembered.sourceFile));
+		const rememberedKey = [...rememberedCssSources.entries()].find(([, entry]) => entry === remembered)?.[0];
+		if (!rememberedKey || !path.isAbsolute(file)) return;
+		try {
+			const source = await readFile(file, "utf8");
+			if (/\.(?:vue|uvue|nvue|svelte|mpx)$/i.test(file)) {
+				const { query } = parseVueRequest(remembered.sourceFile);
+				const styleSource = extractSfcStyleBlock(source, query.type === "style" ? query.index : void 0);
+				return styleSource === void 0 ? void 0 : refreshRememberedCssSourceEntry(rememberedKey, remembered, remembered.sourceFile, styleSource);
+			}
+			if (isSourceStyleRequest(file)) return refreshRememberedCssSourceEntry(rememberedKey, remembered, remembered.sourceFile, source);
+		} catch (error) {
+			debug("refresh remembered css source before bundle replay failed: %s %O", file, error);
+		}
+	};
+	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,
+		getExtraOptions: () => resolveUniAppXNativeCssHandlerOptions(opts)
+	});
+	const generateTailwindCssForVitePipeline = async (id, code, hookContext) => {
+		if (!shouldOwnTailwindGeneration) return;
+		await runtimeState.readyPromise;
+		await waitForSourceCandidateSyncs();
+		const file = cleanUrl(id);
+		const rootDir = resolvedConfig?.root ? path.resolve(resolvedConfig.root) : process$1.cwd();
+		const isNativeAppStyleTarget = resolveUniUtsPlatform().isApp;
+		const outputFile = resolveViteCssPipelineOutputFile(file, opts, rootDir, generatorOptions.target === "web", isNativeAppStyleTarget);
+		const runtime = getRecordedGeneratorCandidates() ?? getSourceCandidates() ?? await ensureRuntimeClassSet();
+		const cssHandlerOptions = transformCssHandlerOptions.getCssHandlerOptions(outputFile);
+		const generated = await generateCssByGenerator({
+			opts,
+			runtimeState,
+			runtime,
+			rawSource: code,
+			file,
+			cssHandlerOptions,
+			cssUserHandlerOptions: transformCssHandlerOptions.getCssUserHandlerOptions(outputFile),
+			getSourceCandidatesForEntries,
+			styleHandler,
+			debug,
+			previousCss: viteGeneratedCssByFile.get(file),
+			deferEmptyScopedCssSource: true
+		});
+		if (!generated) return;
+		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 });
+		if (isNativeAppStyleTarget && outputFile.endsWith(".css")) hookContext?.emitFile?.({
+			type: "asset",
+			fileName: outputFile,
+			source: generated.css
+		});
+		markViteProcessedCssSource(file);
+		rememberTailwindRootCssModule(id);
+		recordGeneratorCandidates(runtime);
+		rememberCssSource({
+			outputFile,
+			rawSource: code,
+			sourceFile: id
+		});
+		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),
+		onCssSourceTransform: (id, code) => refreshRememberedCssSourceBySourceFile(id, code),
+		shouldGenerateCss: (_id, code) => hasVitePipelineTailwindGenerationDirective(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,
+		refreshRememberedCssSource,
+		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,
+		generateCss: generateTailwindCssForVitePipeline,
+		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$1.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 };