weapp-tailwindcss 4.12.0 → 5.0.0-next.2

package/dist/vite-BC9U7ahn.js

@@ -0,0 +1,2199 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_generator = require("./generator-mmhXzZnv.js");
+const require_patcher_options = require("./patcher-options-6gJN2EXy.js");
+const require_recorder = require("./recorder-gYSNLfOP.js");
+const require_utils = require("./utils-DmC9_In3.js");
+const require_logger = require("./logger-BZ45DZJT.js");
+const require_generator_css = require("./generator-css-D3OdPRiS.js");
+const require_css_imports = require("./css-imports-BbrbluP9.js");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let tailwindcss_patch = require("tailwindcss-patch");
+let node_buffer = require("node:buffer");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_fs_promises = require("node:fs/promises");
+let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+let magic_string = require("magic-string");
+magic_string = require_chunk.__toESM(magic_string);
+let _weapp_tailwindcss_shared_extractors = require("@weapp-tailwindcss/shared/extractors");
+let htmlparser2 = require("htmlparser2");
+let fast_glob = require("fast-glob");
+fast_glob = require_chunk.__toESM(fast_glob);
+let _weapp_tailwindcss_postcss_html_transform = require("@weapp-tailwindcss/postcss/html-transform");
+_weapp_tailwindcss_postcss_html_transform = require_chunk.__toESM(_weapp_tailwindcss_postcss_html_transform);
+let postcss_load_config = require("postcss-load-config");
+postcss_load_config = require_chunk.__toESM(postcss_load_config);
+let _vue_compiler_dom = require("@vue/compiler-dom");
+let _vue_compiler_sfc = require("@vue/compiler-sfc");
+let comment_json = require("comment-json");
+//#region src/uni-app-x/component-local-style.ts
+const EXPRESSION_WRAPPER_PREFIX = "(\n";
+const EXPRESSION_WRAPPER_SUFFIX = "\n)";
+const COMPONENT_RE = /(?:^|[/\\])components(?:[/\\].+)?\.(?:uvue|nvue)$/;
+function createStableHash(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 extractLiteralValue(path) {
+	const allowDoubleQuotes = path.isTemplateElement();
+	if (path.isStringLiteral()) return {
+		allowDoubleQuotes,
+		literal: path.node.value,
+		offset: 1
+	};
+	return {
+		allowDoubleQuotes,
+		literal: typeof path.node.value === "string" ? path.node.value : path.node.value.raw,
+		offset: 0
+	};
+}
+function createAlias(fileId, utility, index) {
+	return `wtu-${createStableHash(`${fileId}:${utility}`)}-${index.toString(36)}`;
+}
+function isRuntimeCandidate(candidate, runtimeSet) {
+	if (!runtimeSet || runtimeSet.size === 0) return false;
+	return runtimeSet.has(candidate) || runtimeSet.has(require_recorder.replaceWxml(candidate));
+}
+function shouldEnableComponentLocalStyle(id) {
+	return COMPONENT_RE.test(id);
+}
+var UniAppXComponentLocalStyleCollector = class {
+	constructor(fileId, runtimeSet) {
+		this.fileId = fileId;
+		this.runtimeSet = runtimeSet;
+		this.aliasByUtility = /* @__PURE__ */ new Map();
+		this.aliasByLookup = /* @__PURE__ */ new Map();
+	}
+	ensureAlias(utility) {
+		const cached = this.aliasByUtility.get(utility);
+		if (cached) return cached;
+		const alias = createAlias(this.fileId, utility, this.aliasByUtility.size);
+		this.aliasByUtility.set(utility, alias);
+		this.aliasByLookup.set(utility, alias);
+		this.aliasByLookup.set(require_recorder.replaceWxml(utility), alias);
+		return alias;
+	}
+	rewriteLiteral(literal, shouldInclude) {
+		const candidates = (0, _weapp_tailwindcss_shared_extractors.splitCode)(literal);
+		if (candidates.length === 0) return literal;
+		let rewritten = literal;
+		for (const candidate of candidates) {
+			if (!shouldInclude(candidate)) continue;
+			rewritten = rewritten.replace(candidate, this.ensureAlias(candidate));
+		}
+		return rewritten;
+	}
+	collectAndRewriteStaticClass(literal) {
+		return this.rewriteLiteral(literal, (candidate) => isRuntimeCandidate(candidate, this.runtimeSet));
+	}
+	collectRuntimeClasses(rawSource, options = {}) {
+		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+		try {
+			const analysis = require_recorder.analyzeSource(require_recorder.babelParse(wrapped, {
+				plugins: ["typescript"],
+				sourceType: options.wrapExpression ? "module" : "unambiguous"
+			}), {}, void 0, false);
+			for (const path of analysis.targetPaths) {
+				const { literal, allowDoubleQuotes } = extractLiteralValue(path);
+				const candidates = (0, _weapp_tailwindcss_shared_extractors.splitCode)(literal, allowDoubleQuotes);
+				const classContext = options.wrapExpression || require_recorder.isClassContextLiteralPath(path);
+				for (const candidate of candidates) {
+					if (!candidate || !classContext && !isRuntimeCandidate(candidate, this.runtimeSet)) continue;
+					if (isRuntimeCandidate(candidate, this.runtimeSet)) this.ensureAlias(candidate);
+				}
+			}
+		} catch {}
+	}
+	rewriteTransformedCode(rawSource, options = {}) {
+		if (this.aliasByLookup.size === 0) return rawSource;
+		const wrapped = options.wrapExpression ? `${EXPRESSION_WRAPPER_PREFIX}${rawSource}${EXPRESSION_WRAPPER_SUFFIX}` : rawSource;
+		try {
+			const analysis = require_recorder.analyzeSource(require_recorder.babelParse(wrapped, {
+				plugins: ["typescript"],
+				sourceType: options.wrapExpression ? "module" : "unambiguous"
+			}), {}, void 0, false);
+			if (analysis.targetPaths.length === 0) return rawSource;
+			const updater = new require_recorder.JsTokenUpdater();
+			for (const path of analysis.targetPaths) {
+				const { literal, allowDoubleQuotes, offset } = extractLiteralValue(path);
+				const candidates = (0, _weapp_tailwindcss_shared_extractors.splitCode)(literal, allowDoubleQuotes);
+				if (candidates.length === 0) continue;
+				let rewritten = literal;
+				let mutated = false;
+				for (const candidate of candidates) {
+					const alias = this.aliasByLookup.get(candidate);
+					if (!alias) continue;
+					const replaced = rewritten.replace(candidate, alias);
+					if (replaced !== rewritten) {
+						rewritten = replaced;
+						mutated = true;
+					}
+				}
+				if (!mutated || typeof path.node.start !== "number" || typeof path.node.end !== "number") continue;
+				updater.addToken({
+					start: path.node.start + offset,
+					end: path.node.end - offset,
+					value: rewritten,
+					path
+				});
+			}
+			if (updater.length === 0) return rawSource;
+			const ms = new magic_string.default(wrapped);
+			updater.updateMagicString(ms);
+			if (options.wrapExpression) {
+				ms.remove(0, 2);
+				ms.remove(wrapped.length - 2, wrapped.length);
+			}
+			return ms.toString();
+		} catch {
+			return rawSource;
+		}
+	}
+	hasStyles() {
+		return this.aliasByUtility.size > 0;
+	}
+	toStyleBlock() {
+		if (!this.hasStyles()) return "";
+		const lines = ["<style scoped>"];
+		for (const [utility, alias] of this.aliasByUtility) {
+			lines.push(`.${alias} {`);
+			lines.push(`  @apply ${utility};`);
+			lines.push("}");
+		}
+		lines.push("</style>");
+		return `${lines.join("\n")}\n`;
+	}
+};
+//#endregion
+//#region src/uni-app-x/transform.ts
+function traverse(node, visitor) {
+	visitor(node);
+	if (Array.isArray(node.children)) {
+		for (const child of node.children) if (child && typeof child === "object" && "type" in child) traverse(child, visitor);
+	}
+}
+function updateStaticAttribute(ms, prop, content = prop.value?.content) {
+	if (!prop.value) return;
+	const start = prop.value.loc.start.offset + 1;
+	const end = prop.value.loc.end.offset - 1;
+	if (start < end) ms.update(start, end, require_recorder.replaceWxml(content ?? ""));
+}
+function updateStaticAttributeWithLocalStyle(ms, prop, collector, content = prop.value?.content) {
+	if (!prop.value) return;
+	const start = prop.value.loc.start.offset + 1;
+	const end = prop.value.loc.end.offset - 1;
+	if (start < end) ms.update(start, end, collector.collectAndRewriteStaticClass(content ?? ""));
+}
+function updateDirectiveExpression(ms, prop, jsHandler, runtimeSet) {
+	if (prop.exp?.type !== _vue_compiler_dom.NodeTypes.SIMPLE_EXPRESSION) return;
+	const expression = prop.exp.content;
+	const start = prop.exp.loc.start.offset;
+	const end = prop.exp.loc.end.offset;
+	if (start >= end) return;
+	const generated = require_recorder.generateCode(expression, {
+		jsHandler,
+		runtimeSet,
+		wrapExpression: true
+	});
+	ms.update(start, end, generated);
+}
+function updateDirectiveExpressionWithLocalStyle(ms, prop, jsHandler, collector, runtimeSet) {
+	if (prop.exp?.type !== _vue_compiler_dom.NodeTypes.SIMPLE_EXPRESSION) return;
+	const expression = prop.exp.content;
+	const start = prop.exp.loc.start.offset;
+	const end = prop.exp.loc.end.offset;
+	if (start >= end) return;
+	collector.collectRuntimeClasses(expression, { wrapExpression: true });
+	const generated = require_recorder.generateCode(expression, {
+		jsHandler,
+		runtimeSet,
+		wrapExpression: true
+	});
+	ms.update(start, end, collector.rewriteTransformedCode(generated, { wrapExpression: true }));
+}
+function shouldHandleAttribute(tag, attrName, disabledDefaultTemplateHandler, matchCustomAttribute) {
+	const lowerName = attrName.toLowerCase();
+	const shouldHandleDefault = !disabledDefaultTemplateHandler && lowerName === "class";
+	const shouldHandleCustom = matchCustomAttribute?.(tag, attrName) ?? false;
+	return {
+		shouldHandleDefault,
+		shouldHandleCustom,
+		shouldHandle: shouldHandleDefault || shouldHandleCustom
+	};
+}
+const defaultCreateJsHandlerOptions = { babelParserOptions: { plugins: ["typescript"] } };
+const UVUE_NVUE_RE$1 = /\.(?:uvue|nvue)(?:\?.*)?$/;
+function transformUVue(code, id, jsHandler, runtimeSet, options = {}) {
+	if (!UVUE_NVUE_RE$1.test(id)) return;
+	const { customAttributesEntities, disabledDefaultTemplateHandler = false } = options;
+	const matchCustomAttribute = require_recorder.createAttributeMatcher(customAttributesEntities);
+	const ms = new magic_string.default(code);
+	const { descriptor, errors } = (0, _vue_compiler_sfc.parse)(code);
+	const localStyleCollector = options.enableComponentLocalStyle && shouldEnableComponentLocalStyle(id) ? new UniAppXComponentLocalStyleCollector(id, runtimeSet) : void 0;
+	if (errors.length === 0) {
+		if (descriptor.template?.ast) traverse(descriptor.template.ast, (node) => {
+			if (node.type !== _vue_compiler_dom.NodeTypes.ELEMENT) return;
+			const tag = node.tag;
+			for (const prop of node.props) if (prop.type === _vue_compiler_dom.NodeTypes.ATTRIBUTE) {
+				const { shouldHandle, shouldHandleDefault } = shouldHandleAttribute(tag, prop.name, disabledDefaultTemplateHandler, matchCustomAttribute);
+				if (!shouldHandle) continue;
+				if (shouldHandleDefault && localStyleCollector) updateStaticAttributeWithLocalStyle(ms, prop, localStyleCollector);
+				else updateStaticAttribute(ms, prop);
+				if (shouldHandleDefault) continue;
+			} else if (prop.type === _vue_compiler_dom.NodeTypes.DIRECTIVE && prop.name === "bind" && prop.arg?.type === _vue_compiler_dom.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic) {
+				const attrName = prop.arg.content;
+				const { shouldHandle } = shouldHandleAttribute(tag, attrName, disabledDefaultTemplateHandler, matchCustomAttribute);
+				if (!shouldHandle) continue;
+				if (attrName.toLowerCase() === "class" && localStyleCollector) updateDirectiveExpressionWithLocalStyle(ms, prop, jsHandler, localStyleCollector, runtimeSet);
+				else updateDirectiveExpression(ms, prop, jsHandler, runtimeSet);
+			}
+		});
+		if (descriptor.script) {
+			localStyleCollector?.collectRuntimeClasses(descriptor.script.content);
+			const { code } = jsHandler(descriptor.script.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+			ms.update(descriptor.script.loc.start.offset, descriptor.script.loc.end.offset, localStyleCollector ? localStyleCollector.rewriteTransformedCode(code) : code);
+		}
+		if (descriptor.scriptSetup) {
+			localStyleCollector?.collectRuntimeClasses(descriptor.scriptSetup.content);
+			const { code } = jsHandler(descriptor.scriptSetup.content, runtimeSet ?? /* @__PURE__ */ new Set(), defaultCreateJsHandlerOptions);
+			ms.update(descriptor.scriptSetup.loc.start.offset, descriptor.scriptSetup.loc.end.offset, localStyleCollector ? localStyleCollector.rewriteTransformedCode(code) : code);
+		}
+		if (localStyleCollector?.hasStyles()) ms.append(`\n${localStyleCollector.toStyleBlock()}`);
+	}
+	const result = {
+		code: ms.toString(),
+		map: null
+	};
+	Object.defineProperty(result, "map", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			return ms.generateMap();
+		}
+	});
+	return result;
+}
+//#endregion
+//#region src/bundlers/vite/query.ts
+function parseVueRequest(id) {
+	const [filename, 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/bundlers/vite/utils.ts
+function slash(p) {
+	return (0, _weapp_tailwindcss_shared.ensurePosix)(p);
+}
+const isWindows = node_process.default.platform === "win32";
+const cssLangRE = new RegExp(`\\.(css|less|sass|scss|styl|stylus|pcss|postcss)($|\\?)`);
+function isCSSRequest(request) {
+	return cssLangRE.test(request);
+}
+function normalizePath(id) {
+	return node_path.default.posix.normalize(isWindows ? (0, _weapp_tailwindcss_shared.ensurePosix)(id) : id);
+}
+async function formatPostcssSourceMap(rawMap, file) {
+	const inputFileDir = node_path.default.dirname(file);
+	const sources = rawMap.sources.map((source) => {
+		const cleanSource = (0, _weapp_tailwindcss_shared.cleanUrl)(decodeURIComponent(source));
+		if (cleanSource[0] === "<" && cleanSource.endsWith(">")) return `\0${cleanSource}`;
+		return normalizePath(node_path.default.resolve(inputFileDir, cleanSource));
+	});
+	return {
+		file,
+		mappings: rawMap.mappings,
+		names: rawMap.names,
+		sources,
+		sourcesContent: rawMap.sourcesContent,
+		version: rawMap.version
+	};
+}
+//#endregion
+//#region src/uni-app-x/style-isolation.ts
+const manifestCache = /* @__PURE__ */ new Map();
+function resolveUniAppXStyleIsolationEnabled(root) {
+	if (!root) return false;
+	const normalizedRoot = node_path.default.resolve(root);
+	const cached = manifestCache.get(normalizedRoot);
+	if (cached !== void 0) return cached;
+	const manifestPath = node_path.default.join(normalizedRoot, "manifest.json");
+	let enabled = false;
+	try {
+		enabled = `${(0, comment_json.parse)(node_fs.default.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
+const preprocessorLangs = new Set([
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+]);
+const INLINE_LANG_RE = /lang\.([a-z]+)/i;
+const PREPROCESSOR_EXT_RE = /\.(?:scss|sass|less|styl|stylus)(?:\?|$)/i;
+const UVUE_NVUE_QUERY_RE = /\.(?:uvue|nvue)(?:\?.*)?$/;
+const UVUE_NVUE_RE = /\.(?:uvue|nvue)$/;
+function isPreprocessorRequest(id, lang) {
+	const normalizedLang = lang?.toLowerCase();
+	if (normalizedLang && preprocessorLangs.has(normalizedLang)) return true;
+	const inlineLangMatch = id.match(INLINE_LANG_RE);
+	if (inlineLangMatch && preprocessorLangs.has(inlineLangMatch[1].toLowerCase())) return true;
+	return PREPROCESSOR_EXT_RE.test(id);
+}
+function resolveUniAppXCssTarget(id) {
+	return UVUE_NVUE_RE.test((0, _weapp_tailwindcss_shared.cleanUrl)(id)) ? "uvue" : void 0;
+}
+function resolveUniAppXJsTransformEnabled$1(uniAppX) {
+	return uniAppX === void 0 ? true : require_logger.isUniAppXEnabled(uniAppX);
+}
+function createUniAppXPlugins(options) {
+	const { appType, customAttributesEntities, disabledDefaultTemplateHandler, isIosPlatform: providedIosPlatform, mainCssChunkMatcher, runtimeState, styleHandler, jsHandler, ensureRuntimeClassSet, getResolvedConfig, uniAppX } = options;
+	const resolvedUniAppXOptions = require_logger.resolveUniAppXOptions(uniAppX);
+	const isIosPlatform = providedIosPlatform ?? require_utils.resolveUniUtsPlatform().isAppIos;
+	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+	let componentLocalStyleEnabled;
+	function shouldEnableComponentLocalStyle() {
+		if (!resolvedUniAppXOptions.componentLocalStyles.enabled) {
+			componentLocalStyleEnabled = false;
+			return false;
+		}
+		if (!resolvedUniAppXOptions.componentLocalStyles.onlyWhenStyleIsolationVersion2) {
+			componentLocalStyleEnabled = true;
+			return true;
+		}
+		if (componentLocalStyleEnabled !== void 0) return componentLocalStyleEnabled;
+		const root = getResolvedConfig()?.root;
+		componentLocalStyleEnabled = resolveUniAppXStyleIsolationEnabled(root);
+		return componentLocalStyleEnabled;
+	}
+	async function transformStyle(code, id, query) {
+		const parsed = query ?? parseVueRequest(id).query;
+		if (isCSSRequest(id) || parsed.vue && parsed.type === "style") {
+			const cacheKey = `${mainCssChunkMatcher(id, appType) ? "1" : "0"}:${id}`;
+			let styleHandlerOptions = cssHandlerOptionsCache.get(cacheKey);
+			if (!styleHandlerOptions) {
+				styleHandlerOptions = {
+					isMainChunk: mainCssChunkMatcher(id, appType),
+					uniAppXCssTarget: resolveUniAppXCssTarget(id),
+					uniAppXUnsupported: resolvedUniAppXOptions.uvueUnsupported,
+					postcssOptions: { options: {
+						from: id,
+						map: {
+							inline: false,
+							annotation: false,
+							sourcesContent: true
+						}
+					} }
+				};
+				cssHandlerOptionsCache.set(cacheKey, styleHandlerOptions);
+			}
+			const postcssResult = await styleHandler(code, styleHandlerOptions);
+			const warnings = typeof postcssResult.warnings === "function" ? postcssResult.warnings() : [];
+			for (const warning of warnings) _weapp_tailwindcss_logger.logger.warn(warning.toString());
+			const postcssMap = await formatPostcssSourceMap(postcssResult.map.toJSON(), (0, _weapp_tailwindcss_shared.cleanUrl)(id));
+			return {
+				code: postcssResult.css,
+				map: postcssMap
+			};
+		}
+	}
+	const cssPlugins = [{
+		name: "weapp-tailwindcss:uni-app-x:css",
+		async transform(code, id) {
+			await runtimeState.patchPromise;
+			return transformStyle(code, id);
+		}
+	}, {
+		name: "weapp-tailwindcss:uni-app-x:css:pre",
+		enforce: "pre",
+		async transform(code, id) {
+			await runtimeState.patchPromise;
+			const { query } = parseVueRequest(id);
+			const lang = query.lang;
+			if (isIosPlatform && isPreprocessorRequest(id, lang)) return;
+			return transformStyle(code, id, query);
+		}
+	}];
+	const nvuePlugin = {
+		name: "weapp-tailwindcss:uni-app-x:nvue",
+		enforce: "pre",
+		async buildStart() {
+			await ensureRuntimeClassSet(true);
+		},
+		async transform(code, id) {
+			if (!UVUE_NVUE_QUERY_RE.test(id)) return;
+			const resolvedConfig = getResolvedConfig();
+			const isServeCommand = resolvedConfig?.command === "serve";
+			const isWatchBuild = resolvedConfig?.command === "build" && !!resolvedConfig.build?.watch;
+			const isNonWatchBuild = resolvedConfig?.command === "build" && !resolvedConfig.build?.watch;
+			const currentRuntimeSet = isServeCommand || isWatchBuild || isNonWatchBuild ? await ensureRuntimeClassSet(true) : await ensureRuntimeClassSet();
+			const 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 = require_css_imports.toAbsoluteOutputPath(file, outDir);
+		const rawSource = originalSource.source.toString();
+		await require_generator_css.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/css-finalizer.ts
+function createCssHandlerOptions(opts, majorVersion, file) {
+	return {
+		isMainChunk: opts.mainCssChunkMatcher(file, opts.appType),
+		postcssOptions: { options: { from: file } },
+		majorVersion
+	};
+}
+function shouldGenerateCssByGenerator(opts, file, rawSource, processed) {
+	if (require_generator_css.hasTailwindGeneratedCssMarkers(rawSource) || require_generator_css.hasTailwindSourceDirectives(rawSource)) return true;
+	return processed && shouldFinalizeProcessedCssAsset(opts, file);
+}
+function shouldFinalizeProcessedCssAsset(opts, file) {
+	return require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator).mode === "force" && opts.mainCssChunkMatcher(file, opts.appType);
+}
+function createViteCssFinalizerOutputPlugin(context) {
+	return {
+		name: "weapp-tailwindcss:adaptor:css-finalizer",
+		generateBundle: {
+			order: "post",
+			async handler(_options, bundle) {
+				const { opts, runtimeState, ensureRuntimeClassSet, isCssAssetProcessed, markCssAssetProcessed, debug, getResolvedConfig, recordCssAssetResult, getRecordedGeneratorCandidates, getSourceCandidates, waitForSourceCandidateSyncs, rememberMainCssSource } = context;
+				if (getResolvedConfig()?.command !== "build") return;
+				const entries = Object.entries(bundle).filter(([, output]) => output.type === "asset" && opts.cssMatcher(output.fileName) && (!isCssAssetProcessed(output, output.fileName) || shouldFinalizeProcessedCssAsset(opts, output.fileName)));
+				if (entries.length === 0) return;
+				await runtimeState.patchPromise;
+				await waitForSourceCandidateSyncs?.();
+				const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+				const runtime = getRecordedGeneratorCandidates?.() ?? getSourceCandidates?.() ?? await ensureRuntimeClassSet();
+				const collectedGeneratorCandidates = new Set([...runtime, ...getSourceCandidates?.() ?? []]);
+				const generatorRuntime = runtimeState.twPatcher.majorVersion === 4 && generatorOptions.target === "weapp" ? require_generator.filterUnsupportedMiniProgramTailwindV4Candidates(collectedGeneratorCandidates) : collectedGeneratorCandidates;
+				await Promise.all(entries.map(async ([bundleFile, output]) => {
+					const file = output.fileName || bundleFile;
+					const rawSource = output.source.toString();
+					const cssHandlerOptions = createCssHandlerOptions(opts, runtimeState.twPatcher.majorVersion, file);
+					const cssUserHandlerOptions = {
+						...cssHandlerOptions,
+						isMainChunk: false
+					};
+					const generated = shouldGenerateCssByGenerator(opts, file, rawSource, isCssAssetProcessed(output, file)) ? await require_generator_css.generateCssByGenerator({
+						opts,
+						runtimeState,
+						runtime: generatorRuntime,
+						rawSource,
+						file,
+						cssHandlerOptions,
+						cssUserHandlerOptions,
+						styleHandler: opts.styleHandler,
+						debug
+					}) : void 0;
+					const nextCss = generated?.css ?? (await opts.styleHandler(rawSource, cssHandlerOptions)).css;
+					if (generated) {
+						debug("css finalizer generated result: %s bytes=%d", file, nextCss.length);
+						recordCssAssetResult?.(file, nextCss);
+						if (cssHandlerOptions.isMainChunk) rememberMainCssSource?.(file, rawSource);
+					}
+					output.source = nextCss;
+					markCssAssetProcessed(output, file);
+					opts.onUpdate(file, rawSource, nextCss);
+					debug("css finalizer handle: %s", file);
+				}));
+			}
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/vite/bundle-entries.ts
+function readOutputEntry(entry) {
+	if (entry.output.type === "chunk") return entry.output.code;
+	const source = entry.output.source;
+	if (typeof source === "string") return source;
+	if (source instanceof Uint8Array) return node_buffer.Buffer.from(source).toString();
+	const fallbackSource = source;
+	if (fallbackSource == null) return;
+	if (typeof fallbackSource.toString === "function") return fallbackSource.toString();
+}
+function isJavaScriptEntry(entry) {
+	if (entry.output.type === "chunk") return true;
+	return entry.fileName.endsWith(".js");
+}
+function createBundleModuleGraphOptions(outputDir, entries) {
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [id, entry] of entries) normalizedEntries.set(require_css_imports.normalizeOutputPathKey(id), entry);
+	const getEntry = (id) => entries.get(id) ?? normalizedEntries.get(require_css_imports.normalizeOutputPathKey(id));
+	return {
+		resolve(specifier, importer) {
+			return require_css_imports.resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => Boolean(getEntry(candidate)));
+		},
+		load(id) {
+			const entry = getEntry(id);
+			if (!entry) return;
+			return readOutputEntry(entry);
+		},
+		filter(id) {
+			return Boolean(getEntry(id));
+		}
+	};
+}
+function applyLinkedResults(linked, entries, onLinkedUpdate, onApplied) {
+	if (!linked) return;
+	const normalizedEntries = /* @__PURE__ */ new Map();
+	for (const [entryId, entry] of entries) normalizedEntries.set(require_css_imports.normalizeOutputPathKey(entryId), entry);
+	for (const [id, { code }] of Object.entries(linked)) {
+		const entry = entries.get(id) ?? normalizedEntries.get(require_css_imports.normalizeOutputPathKey(id));
+		if (!entry) continue;
+		const previous = readOutputEntry(entry);
+		if (previous == null || previous === code) continue;
+		if (entry.output.type === "chunk") entry.output.code = code;
+		else entry.output.source = code;
+		onApplied?.(entry, code);
+		onLinkedUpdate(entry.fileName, previous, code);
+	}
+}
+//#endregion
+//#region src/bundlers/vite/runtime-affecting-signature.ts
+const CSS_BLOCK_COMMENT_RE = /\/\*[\s\S]*?\*\//g;
+const CSS_AROUND_PUNCTUATION_RE = /\s*([{}:;,>+~()])\s*/g;
+const CSS_TRAILING_DECLARATION_SEMICOLON_RE = /;\}/g;
+const CSS_WHITESPACE_RE = /\s+/g;
+function createHtmlRuntimeAffectingSignature(source) {
+	try {
+		const parts = [];
+		const parser = new htmlparser2.Parser({
+			onattribute(name, value) {
+				parts.push(`a:${name}=${value}`);
+			},
+			oncomment(data) {
+				parts.push(`c:${data}`);
+			},
+			ontext(data) {
+				const value = data.trim();
+				if (value.length > 0) parts.push(`t:${value}`);
+			}
+		}, { xmlMode: true });
+		parser.write(source);
+		parser.end();
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createJsRuntimeAffectingSignature(source) {
+	try {
+		const ast = require_recorder.babelParse(source, {
+			cache: true,
+			cacheKey: "vite-runtime-affecting:unambiguous",
+			plugins: ["jsx", "typescript"],
+			sourceType: "unambiguous"
+		});
+		const parts = [];
+		require_recorder.traverse(ast, {
+			noScope: true,
+			StringLiteral(path) {
+				parts.push(`s:${path.node.value}`);
+			},
+			TemplateElement(path) {
+				parts.push(`t:${path.node.value.raw}`);
+			},
+			JSXText(path) {
+				const value = path.node.value.trim();
+				if (value.length > 0) parts.push(`x:${value}`);
+			}
+		});
+		const comments = ast.comments;
+		if (Array.isArray(comments)) {
+			for (const comment of comments) if (typeof comment?.value === "string" && comment.value.length > 0) parts.push(`c:${comment.value}`);
+		}
+		return parts.join("\n");
+	} catch {
+		return source;
+	}
+}
+function createCssRuntimeAffectingSignature(source) {
+	return source.replace(CSS_BLOCK_COMMENT_RE, "").replace(CSS_AROUND_PUNCTUATION_RE, "$1").replace(CSS_TRAILING_DECLARATION_SEMICOLON_RE, "}").replace(CSS_WHITESPACE_RE, " ").trim();
+}
+function createRuntimeAffectingSourceSignature(source, type) {
+	if (type === "html") return createHtmlRuntimeAffectingSignature(source);
+	if (type === "js") return createJsRuntimeAffectingSignature(source);
+	if (type === "css") return createCssRuntimeAffectingSignature(source);
+	return source;
+}
+//#endregion
+//#region src/bundlers/vite/bundle-state.ts
+function createBundleBuildState() {
+	return {
+		iteration: 0,
+		sourceHashByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingSignatureByFile: /* @__PURE__ */ new Map(),
+		runtimeAffectingHashByFile: /* @__PURE__ */ new Map(),
+		linkedByEntry: /* @__PURE__ */ new Map(),
+		dependentsByLinkedFile: /* @__PURE__ */ new Map()
+	};
+}
+function createChangedByType() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set(),
+		other: /* @__PURE__ */ new Set()
+	};
+}
+function createProcessFiles() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set()
+	};
+}
+function readEntrySource(output) {
+	if (output.type === "chunk") return output.code;
+	return output.source.toString();
+}
+function classifyBundleEntry(file, opts) {
+	if (opts.cssMatcher(file)) return "css";
+	if (opts.htmlMatcher(file)) return "html";
+	if (opts.jsMatcher(file) || opts.wxsMatcher(file)) return "js";
+	return "other";
+}
+function collectJsEntries(fileName, output, outDir, store) {
+	const entry = {
+		fileName,
+		output
+	};
+	if (!isJavaScriptEntry(entry)) return;
+	const absolute = require_css_imports.toAbsoluteOutputPath(fileName, outDir);
+	store.set(absolute, entry);
+}
+function markProcessFile(type, file, processFiles) {
+	if (type === "html" || type === "js" || type === "css") processFiles[type].add(file);
+}
+function buildBundleSnapshot(bundle, opts, outDir, state, forceAll = false) {
+	const sourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingSignatureByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingHashByFile = /* @__PURE__ */ new Map();
+	const changedByType = createChangedByType();
+	const runtimeAffectingChangedByType = createChangedByType();
+	const processFiles = createProcessFiles();
+	const linkedImpactsByEntry = /* @__PURE__ */ new Map();
+	const jsEntries = /* @__PURE__ */ new Map();
+	const entries = [];
+	const firstRun = state.linkedByEntry.size === 0;
+	for (const [file, output] of Object.entries(bundle)) {
+		const type = classifyBundleEntry(file, opts);
+		const source = readEntrySource(output);
+		const hash = opts.cache.computeHash(source);
+		sourceHashByFile.set(file, hash);
+		const previousHash = state.sourceHashByFile.get(file);
+		const changed = previousHash == null || previousHash !== hash;
+		const previousRuntimeAffectingSignature = state.runtimeAffectingSignatureByFile.get(file);
+		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+		const canReuseRuntimeAffectingSignature = !changed && previousRuntimeAffectingSignature != null && previousRuntimeAffectingHash != null;
+		const runtimeAffectingSignature = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingSignature : createRuntimeAffectingSourceSignature(source, type);
+		const runtimeAffectingHash = canReuseRuntimeAffectingSignature ? previousRuntimeAffectingHash : opts.cache.computeHash(runtimeAffectingSignature);
+		runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+		runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+		if (changed) changedByType[type].add(file);
+		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) runtimeAffectingChangedByType[type].add(file);
+		if (forceAll || firstRun) markProcessFile(type, file, processFiles);
+		else if (type === "html") processFiles.html.add(file);
+		else if (changed && (type === "js" || type === "css")) processFiles[type].add(file);
+		collectJsEntries(file, output, outDir, jsEntries);
+		entries.push({
+			file,
+			output,
+			source,
+			type
+		});
+	}
+	if (!forceAll && !firstRun) for (const changedFile of changedByType.js) {
+		const dependents = state.dependentsByLinkedFile.get(changedFile);
+		if (!dependents) continue;
+		for (const entryFile of dependents) {
+			processFiles.js.add(entryFile);
+			let impacts = linkedImpactsByEntry.get(entryFile);
+			if (!impacts) {
+				impacts = /* @__PURE__ */ new Set();
+				linkedImpactsByEntry.set(entryFile, impacts);
+			}
+			impacts.add(changedFile);
+		}
+	}
+	return {
+		entries,
+		jsEntries,
+		sourceHashByFile,
+		runtimeAffectingSignatureByFile,
+		runtimeAffectingHashByFile,
+		changedByType,
+		runtimeAffectingChangedByType,
+		processFiles,
+		linkedImpactsByEntry
+	};
+}
+function invertLinkedByEntry(linkedByEntry) {
+	const dependentsByLinkedFile = /* @__PURE__ */ new Map();
+	for (const [entryFile, linkedFiles] of linkedByEntry.entries()) for (const linkedFile of linkedFiles) {
+		let dependents = dependentsByLinkedFile.get(linkedFile);
+		if (!dependents) {
+			dependents = /* @__PURE__ */ new Set();
+			dependentsByLinkedFile.set(linkedFile, dependents);
+		}
+		dependents.add(entryFile);
+	}
+	return dependentsByLinkedFile;
+}
+function updateBundleBuildState(state, snapshot, linkedByEntry, options = {}) {
+	const incremental = options.incremental === true;
+	state.iteration += 1;
+	state.sourceHashByFile = incremental ? new Map([...state.sourceHashByFile, ...snapshot.sourceHashByFile]) : snapshot.sourceHashByFile;
+	state.runtimeAffectingSignatureByFile = incremental ? new Map([...state.runtimeAffectingSignatureByFile, ...snapshot.runtimeAffectingSignatureByFile]) : snapshot.runtimeAffectingSignatureByFile;
+	state.runtimeAffectingHashByFile = incremental ? new Map([...state.runtimeAffectingHashByFile, ...snapshot.runtimeAffectingHashByFile]) : snapshot.runtimeAffectingHashByFile;
+	state.linkedByEntry = incremental ? new Map([...state.linkedByEntry, ...linkedByEntry]) : linkedByEntry;
+	state.dependentsByLinkedFile = invertLinkedByEntry(state.linkedByEntry);
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle.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 resolveUniAppXJsTransformEnabled(uniAppX) {
+	return uniAppX === void 0 ? true : require_logger.isUniAppXEnabled(uniAppX);
+}
+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);
+}
+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;
+}
+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:${require_css_imports.normalizeOutputPathKey(node_path.default.dirname(file))}`;
+	return "global";
+}
+function createCssTransformShareScopeKey(opts, file, rawSource) {
+	if (require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator).mode === "force" && opts.mainCssChunkMatcher(file, opts.appType)) return `main:${require_css_imports.normalizeOutputPathKey(file)}`;
+	return createCssTransformShareScope(file, rawSource);
+}
+function createCssRuntimeSignature(runtimeSignature, generatorCandidateSignature) {
+	return `${runtimeSignature}:${generatorCandidateSignature}`;
+}
+function createReplayCssAsset(fileName, source) {
+	return {
+		type: "asset",
+		fileName,
+		name: void 0,
+		source,
+		needsCodeReference: false,
+		names: [],
+		originalFileName: null,
+		originalFileNames: []
+	};
+}
+function hasOmittedKnownBundleFiles(currentBundleFiles, previousBundleFiles) {
+	const currentFileSet = new Set(currentBundleFiles);
+	for (const file of previousBundleFiles) if (!currentFileSet.has(file)) return true;
+	return false;
+}
+const MUSTACHE_EXPRESSION_RE = /\{\{[\s\S]*?\}\}/g;
+const QUOTED_LITERAL_RE = /'([^']*)'|"([^"]*)"|`([^`]*)`/g;
+function isArbitraryValueCandidate(candidate) {
+	return candidate.includes("[") && candidate.includes("]");
+}
+function collectUnescapedDynamicCandidates(source) {
+	const matches = /* @__PURE__ */ new Set();
+	for (const expression of source.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 (0, _weapp_tailwindcss_shared_extractors.splitCode)(literal, true)) {
+				const normalized = candidate.trim();
+				if (!normalized || !isArbitraryValueCandidate(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"]);
+}
+function createGenerateBundleHook(context) {
+	const state = createBundleBuildState();
+	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+	const cssUserHandlerOptionsCache = /* @__PURE__ */ new Map();
+	return async function generateBundle(_opt, bundle) {
+		const { opts, runtimeState, ensureBundleRuntimeClassSet, debug, getResolvedConfig, markCssAssetProcessed, recordCssAssetResult, getSourceCandidates, waitForSourceCandidateSyncs, rememberMainCssSource, getRememberedMainCssSources, getRememberedMainCssSignature, setRememberedMainCssSignature, recordGeneratorCandidates } = context;
+		const { appType, cache, mainCssChunkMatcher, onEnd, onStart, onUpdate, styleHandler, templateHandler, jsHandler, uniAppX } = opts;
+		const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator);
+		const getCssHandlerOptions = (file) => {
+			const majorVersion = runtimeState.twPatcher.majorVersion;
+			const isMainChunk = mainCssChunkMatcher(file, appType);
+			const cacheKey = `${majorVersion ?? "unknown"}:${isMainChunk ? "1" : "0"}:${file}`;
+			const cached = cssHandlerOptionsCache.get(cacheKey);
+			if (cached) return cached;
+			const created = {
+				isMainChunk,
+				postcssOptions: { options: { from: file } },
+				majorVersion
+			};
+			cssHandlerOptionsCache.set(cacheKey, created);
+			return created;
+		};
+		const getCssUserHandlerOptions = (file) => {
+			const cacheKey = `${runtimeState.twPatcher.majorVersion ?? "unknown"}:${file}`;
+			const cached = cssUserHandlerOptionsCache.get(cacheKey);
+			if (cached) return cached;
+			const created = {
+				...getCssHandlerOptions(file),
+				isMainChunk: false
+			};
+			cssUserHandlerOptionsCache.set(cacheKey, created);
+			return created;
+		};
+		await runtimeState.patchPromise;
+		debug("start");
+		onStart();
+		const metrics = createEmptyMetrics();
+		const forceRuntimeRefreshByEnv = node_process.default.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+		const disableDirtyOptimization = node_process.default.env.WEAPP_TW_VITE_DISABLE_DIRTY === "1";
+		const disableJsPrecheck = node_process.default.env.WEAPP_TW_VITE_DISABLE_JS_PRECHECK === "1";
+		const debugCssDiff = node_process.default.env.WEAPP_TW_VITE_DEBUG_CSS_DIFF === "1";
+		const resolvedConfig = getResolvedConfig();
+		const bundleFiles = Object.keys(bundle);
+		const useIncrementalMode = !(resolvedConfig?.command === "build") || hasOmittedKnownBundleFiles(bundleFiles, state.sourceHashByFile.keys());
+		const rootDir = resolvedConfig?.root ? node_path.default.resolve(resolvedConfig.root) : node_process.default.cwd();
+		const outDir = resolvedConfig?.build?.outDir ? node_path.default.resolve(rootDir, resolvedConfig.build.outDir) : rootDir;
+		const snapshot = buildBundleSnapshot(bundle, opts, outDir, state, disableDirtyOptimization || !useIncrementalMode);
+		const useBundleRuntimeClassSet = useIncrementalMode || runtimeState.twPatcher.majorVersion === 4;
+		const forceRuntimeRefreshBySource = useIncrementalMode && hasRuntimeAffectingSourceChanges(snapshot.runtimeAffectingChangedByType);
+		const processFiles = snapshot.processFiles;
+		if (useIncrementalMode) {
+			debug("dirty iteration=%d html=%d[%s] js=%d[%s] css=%d[%s] other=%d[%s]", state.iteration + 1, 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]", state.iteration + 1, processFiles.html.size, formatDebugFileList(processFiles.html), processFiles.js.size, formatDebugFileList(processFiles.js), processFiles.css.size, formatDebugFileList(processFiles.css));
+		} else 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));
+		const jsEntries = snapshot.jsEntries;
+		const normalizedJsEntries = /* @__PURE__ */ new Map();
+		for (const [id, entry] of jsEntries) normalizedJsEntries.set(require_css_imports.normalizeOutputPathKey(id), entry);
+		const getJsEntry = (id) => jsEntries.get(id) ?? normalizedJsEntries.get(require_css_imports.normalizeOutputPathKey(id));
+		const moduleGraphOptions = createBundleModuleGraphOptions(outDir, jsEntries);
+		const runtimeStart = performance.now();
+		const runtime = useBundleRuntimeClassSet ? await ensureBundleRuntimeClassSet(snapshot, forceRuntimeRefreshByEnv) : await context.ensureRuntimeClassSet(forceRuntimeRefreshByEnv);
+		const shouldFilterTailwindV4MiniProgramCandidates = runtimeState.twPatcher.majorVersion === 4 && generatorOptions.target === "weapp";
+		await waitForSourceCandidateSyncs?.();
+		const sourceCandidates = getSourceCandidates?.() ?? /* @__PURE__ */ new Set();
+		const collectedGeneratorCandidates = generatorOptions.mode === "force" ? new Set(sourceCandidates) : new Set([...runtime, ...sourceCandidates]);
+		const generatorRuntime = collectLegacyContainerCompatCandidates(sourceCandidates, shouldFilterTailwindV4MiniProgramCandidates ? require_generator.filterUnsupportedMiniProgramTailwindV4Candidates(collectedGeneratorCandidates) : collectedGeneratorCandidates);
+		const generatorCandidateSignature = createCandidateSignature(generatorRuntime);
+		recordGeneratorCandidates?.(generatorRuntime);
+		const defaultTemplateHandlerOptions = { runtimeSet: runtime };
+		metrics.runtimeSet = measureElapsed(runtimeStart);
+		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", runtime.size);
+		const runtimeSignature = require_logger.getRuntimeClassSetSignature(runtimeState.twPatcher) ?? "runtime:missing";
+		const handleLinkedUpdate = (fileName, previous, next) => {
+			onUpdate(fileName, previous, next);
+			debug("js linked handle: %s", fileName);
+		};
+		const pendingLinkedUpdates = [];
+		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, jsEntries, handleLinkedUpdate, scheduleLinkedApply);
+		};
+		const createHandlerOptions = (absoluteFilename, extra) => ({
+			...extra,
+			filename: absoluteFilename,
+			tailwindcssMajorVersion: runtimeState.twPatcher.majorVersion,
+			moduleGraph: moduleGraphOptions,
+			babelParserOptions: {
+				...extra?.babelParserOptions ?? {},
+				sourceFilename: absoluteFilename
+			}
+		});
+		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 (!processFiles.html.has(file)) continue;
+				const rawSource = originalEntrySource;
+				tasks.push(require_generator_css.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);
+						if (unresolvedDynamicCandidates.length > 0) {
+							_weapp_tailwindcss_logger.logger.warn("检测到 WXML 动态类名未完成转译，已回退到完整 runtimeSet 重试: %s -> %O", file, unresolvedDynamicCandidates);
+							transformed = await templateHandler(rawSource, { runtimeSet: await context.ensureRuntimeClassSet(true) });
+							unresolvedDynamicCandidates = collectUnescapedDynamicCandidates(transformed);
+							if (unresolvedDynamicCandidates.length > 0) _weapp_tailwindcss_logger.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 = originalEntrySource;
+				const cssRuntimeAffectingSignature = snapshot.runtimeAffectingSignatureByFile.get(file) ?? rawSource;
+				const cssShareScope = createCssTransformShareScopeKey(opts, file, rawSource);
+				const cssHandlerOptions = getCssHandlerOptions(file);
+				const cssRuntimeSignature = createCssRuntimeSignature(runtimeSignature, generatorCandidateSignature);
+				const cssSharedCacheKey = `${cssShareScope}:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}:${cssHandlerOptions.isMainChunk ? "1" : "0"}:${cssRuntimeAffectingSignature}`;
+				tasks.push(require_generator_css.processCachedTask({
+					cache,
+					cacheKey: file,
+					hashKey: `${file}:css:${cssRuntimeSignature}:${runtimeState.twPatcher.majorVersion ?? "unknown"}`,
+					hash: `${getSnapshotHash(snapshot.runtimeAffectingHashByFile, file, cssRuntimeAffectingSignature)}:${generatorCandidateSignature}`,
+					applyResult(source) {
+						originalSource.source = source;
+						markCssAssetProcessed?.(originalSource, file);
+						if (cssHandlerOptions.isMainChunk) rememberMainCssSource?.(file, rawSource, cssRuntimeSignature);
+					},
+					onCacheHit() {
+						metrics.css.cacheHits++;
+						debug("css cache hit: %s", file);
+					},
+					async transform() {
+						if (cssSharedCacheKey) {
+							const sharedCssTask = sharedCssResultCache.get(cssSharedCacheKey);
+							if (sharedCssTask != null) {
+								metrics.css.cacheHits++;
+								debug("css shared hit: %s", file);
+								const sharedCss = await sharedCssTask;
+								onUpdate(file, rawSource, sharedCss);
+								return { result: sharedCss };
+							}
+						}
+						const runTransform = async () => {
+							const start = performance.now();
+							await runtimeState.patchPromise;
+							const generated = await require_generator_css.generateCssByGenerator({
+								opts,
+								runtimeState,
+								runtime: generatorRuntime,
+								rawSource,
+								file,
+								cssHandlerOptions,
+								cssUserHandlerOptions: getCssUserHandlerOptions(file),
+								styleHandler,
+								debug
+							});
+							if (generated) {
+								if (debugCssDiff) debug("css diff %s: %s", file, summarizeStringDiff(rawSource, generated.css));
+								debug("css generated result: %s bytes=%d", file, generated.css.length);
+								recordCssAssetResult?.(file, generated.css);
+								metrics.css.elapsed += measureElapsed(start);
+								metrics.css.transformed++;
+								debug("css handle via tailwind v%s engine(%s): %s", runtimeState.twPatcher.majorVersion, generated.target, file);
+								return generated.css;
+							}
+							const { css } = await styleHandler(rawSource, getCssHandlerOptions(file));
+							if (debugCssDiff) debug("css diff %s: %s", file, summarizeStringDiff(rawSource, css));
+							metrics.css.elapsed += measureElapsed(start);
+							metrics.css.transformed++;
+							return css;
+						};
+						const cssTask = cssSharedCacheKey ? sharedCssResultCache.get(cssSharedCacheKey) ?? runTransform() : runTransform();
+						if (cssSharedCacheKey && !sharedCssResultCache.has(cssSharedCacheKey)) sharedCssResultCache.set(cssSharedCacheKey, cssTask);
+						const css = await cssTask;
+						onUpdate(file, rawSource, css);
+						debug("css handle: %s", file);
+						return { result: css };
+					}
+				}));
+				continue;
+			}
+			if (type !== "js") continue;
+			metrics.js.total++;
+			const shouldTransformJs = !useIncrementalMode || processFiles.js.has(file);
+			if (!shouldTransformJs) debug("js skip transform (clean), replay cache: %s", file);
+			if (originalSource.type === "chunk") {
+				const absoluteFile = node_path.default.resolve(outDir, file);
+				const initialRawSource = originalEntrySource;
+				const linkedSet = useIncrementalMode ? /* @__PURE__ */ new Set() : void 0;
+				if (linkedByEntry && linkedSet) linkedByEntry.set(file, linkedSet);
+				jsTaskFactories.push(async () => {
+					const hashSalt = createJsHashSalt(runtimeSignature, useIncrementalMode ? createLinkedImpactSignature(file, snapshot.linkedImpactsByEntry, snapshot.sourceHashByFile) : void 0);
+					await require_generator_css.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 && require_recorder.shouldSkipJsTransform(rawSource, handlerOptions)) {
+								metrics.js.elapsed += measureElapsed(start);
+								metrics.js.transformed++;
+								return { result: rawSource };
+							}
+							const { code, linked } = await jsHandler(rawSource, runtime, handlerOptions);
+							metrics.js.elapsed += measureElapsed(start);
+							metrics.js.transformed++;
+							onUpdate(file, rawSource, code);
+							debug("js handle: %s", file);
+							if (linked) for (const id of Object.keys(linked)) {
+								const linkedEntry = getJsEntry(id);
+								if (linkedEntry && linkedSet) linkedSet.add(linkedEntry.fileName);
+							}
+							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) => {
+					if (linked) for (const id of Object.keys(linked)) {
+						const linkedEntry = getJsEntry(id);
+						if (linkedEntry && linkedSet) linkedSet.add(linkedEntry.fileName);
+					}
+					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: runtime,
+					applyLinkedResults: wrappedApplyLinkedUpdates,
+					uniAppX
+				});
+				jsTaskFactories.push(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(node_path.default.resolve(outDir, file), {
+						uniAppX: resolveUniAppXJsTransformEnabled(uniAppX),
+						babelParserOptions: {
+							plugins: ["typescript"],
+							sourceType: "unambiguous"
+						}
+					});
+					if (!disableJsPrecheck && require_recorder.shouldSkipJsTransform(currentSource, precheckOptions)) {
+						metrics.js.elapsed += measureElapsed(start);
+						metrics.js.transformed++;
+						return;
+					}
+					await factory();
+					metrics.js.elapsed += measureElapsed(start);
+					metrics.js.transformed++;
+				});
+			}
+		}
+		const cssRuntimeSignature = createCssRuntimeSignature(runtimeSignature, generatorCandidateSignature);
+		if (useIncrementalMode && generatorOptions.mode === "force") for (const [file, rawSource] of getRememberedMainCssSources?.() ?? []) {
+			if (bundleFiles.includes(file) || getRememberedMainCssSignature?.(file) === cssRuntimeSignature) continue;
+			tasks.push((async () => {
+				const start = performance.now();
+				const cssHandlerOptions = getCssHandlerOptions(file);
+				const generated = await require_generator_css.generateCssByGenerator({
+					opts,
+					runtimeState,
+					runtime: generatorRuntime,
+					rawSource,
+					file,
+					cssHandlerOptions,
+					cssUserHandlerOptions: getCssUserHandlerOptions(file),
+					styleHandler,
+					debug
+				});
+				const css = generated?.css ?? (await styleHandler(rawSource, cssHandlerOptions)).css;
+				setRememberedMainCssSignature?.(file, cssRuntimeSignature);
+				if (generated) {
+					recordCssAssetResult?.(file, generated.css);
+					debug("css replay generated result: %s bytes=%d", file, css.length);
+				}
+				const replayAsset = createReplayCssAsset(file, css);
+				if (typeof this.emitFile === "function") this.emitFile({
+					type: "asset",
+					fileName: file,
+					source: css
+				});
+				else bundle[file] = replayAsset;
+				markCssAssetProcessed?.(replayAsset, file);
+				metrics.css.elapsed += measureElapsed(start);
+				metrics.css.transformed++;
+				onUpdate(file, rawSource, css);
+				debug("css replay handle: %s", file);
+			})());
+		}
+		require_css_imports.pushConcurrentTaskFactories(tasks, jsTaskFactories);
+		await Promise.all(tasks);
+		for (const apply of pendingLinkedUpdates) apply();
+		updateBundleBuildState(state, snapshot, useIncrementalMode ? linkedByEntry ?? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Map(), { incremental: useIncrementalMode });
+		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));
+		onEnd();
+		debug("end");
+	};
+}
+//#endregion
+//#region src/bundlers/vite/incremental-runtime-class-set.ts
+const debug$1 = require_recorder.createDebug("[vite:runtime-set] ");
+const EXTENSION_DOT_PREFIX_RE = /^\./;
+function createExtractOptions(context, source) {
+	return {
+		cwd: context.projectRoot,
+		base: context.base,
+		baseFallbacks: context.baseFallbacks,
+		css: context.css,
+		content: source,
+		extension: "html"
+	};
+}
+function createRuntimeEntries(snapshot) {
+	return snapshot.entries.filter((entry) => entry.type === "html" || entry.type === "js");
+}
+function collectChangedRuntimeFiles(snapshot) {
+	return new Set([...snapshot.runtimeAffectingChangedByType.html, ...snapshot.runtimeAffectingChangedByType.js]);
+}
+function resolveEntryExtension(entry) {
+	const ext = entry.file.split(/[?#]/, 1)[0]?.split(".").pop()?.replace(EXTENSION_DOT_PREFIX_RE, "") ?? "";
+	if (ext.length > 0) return ext;
+	return entry.type === "html" ? "html" : "js";
+}
+function createCandidateValidationSource(candidates) {
+	return [...new Set(candidates)].sort().join("\n");
+}
+function removeCandidateSet$1(candidateCountByClass, runtimeSet, candidates) {
+	for (const className of candidates) {
+		const count = candidateCountByClass.get(className);
+		if (count == null) continue;
+		if (count <= 1) {
+			candidateCountByClass.delete(className);
+			runtimeSet.delete(className);
+			continue;
+		}
+		candidateCountByClass.set(className, count - 1);
+	}
+}
+function addCandidateSet$1(candidateCountByClass, runtimeSet, candidates) {
+	for (const className of candidates) {
+		const nextCount = (candidateCountByClass.get(className) ?? 0) + 1;
+		candidateCountByClass.set(className, nextCount);
+		runtimeSet.add(className);
+	}
+}
+function createBundleRuntimeClassSetManager(options = {}) {
+	const customExtractCandidates = options.extractCandidates;
+	const extractCandidates = customExtractCandidates ?? tailwindcss_patch.extractValidCandidates;
+	const extractRawCandidates = options.extractRawCandidates ?? tailwindcss_patch.extractRawCandidatesWithPositions;
+	const runtimeSet = /* @__PURE__ */ new Set();
+	const candidateCountByClass = /* @__PURE__ */ new Map();
+	const candidatesByFile = /* @__PURE__ */ new Map();
+	const candidateValidityCache = /* @__PURE__ */ new Map();
+	let runtimeSignature;
+	let validationContext;
+	let designSystemPromise;
+	async function reset() {
+		runtimeSet.clear();
+		candidateCountByClass.clear();
+		candidatesByFile.clear();
+		candidateValidityCache.clear();
+		runtimeSignature = void 0;
+		validationContext = void 0;
+		designSystemPromise = void 0;
+	}
+	async function resolveValidationContextCached(patcher) {
+		if (!validationContext) validationContext = await require_generator.resolveTailwindV4SourceFromPatcher(patcher);
+		return validationContext;
+	}
+	async function loadDesignSystem(context) {
+		if (!designSystemPromise) designSystemPromise = (0, tailwindcss_patch.loadTailwindV4DesignSystem)(context);
+		return designSystemPromise;
+	}
+	function populateCandidateValidityCacheFromDesignSystem(designSystem, unknownCandidates) {
+		const parsedCandidates = [...unknownCandidates].filter((candidate) => designSystem.parseCandidate(candidate).length > 0);
+		const cssByCandidate = parsedCandidates.length > 0 ? designSystem.candidatesToCss(parsedCandidates) : [];
+		const validCandidates = /* @__PURE__ */ new Set();
+		for (let index = 0; index < parsedCandidates.length; index += 1) {
+			const candidate = parsedCandidates[index];
+			const css = cssByCandidate[index];
+			if (candidate && typeof css === "string" && css.trim().length > 0) validCandidates.add(candidate);
+		}
+		for (const candidate of unknownCandidates) candidateValidityCache.set(candidate, validCandidates.has(candidate));
+	}
+	async function validateUnknownCandidates(patcher, unknownCandidates) {
+		if (unknownCandidates.size === 0) return;
+		const context = await resolveValidationContextCached(patcher);
+		if (!customExtractCandidates) try {
+			populateCandidateValidityCacheFromDesignSystem(await loadDesignSystem(context), unknownCandidates);
+			return;
+		} catch (error) {
+			debug$1("incremental design-system validation failed: %O", error);
+			designSystemPromise = void 0;
+			throw error;
+		}
+		const source = createCandidateValidationSource(unknownCandidates);
+		const validCandidates = new Set(await extractCandidates(createExtractOptions(context, source)));
+		for (const candidate of unknownCandidates) candidateValidityCache.set(candidate, validCandidates.has(candidate));
+	}
+	async function extractEntryRawCandidates(entry) {
+		const matches = await extractRawCandidates(entry.source, resolveEntryExtension(entry));
+		const candidates = /* @__PURE__ */ new Set();
+		for (const match of matches) {
+			const candidate = match?.rawCandidate;
+			if (typeof candidate === "string" && candidate.length > 0) candidates.add(candidate);
+		}
+		return candidates;
+	}
+	async function sync(patcher, snapshot) {
+		const nextSignature = require_logger.getRuntimeClassSetSignature(patcher) ?? "runtime:missing";
+		const runtimeEntries = createRuntimeEntries(snapshot);
+		const runtimeEntriesByFile = new Map(runtimeEntries.map((entry) => [entry.file, entry]));
+		const currentRuntimeFiles = new Set(runtimeEntriesByFile.keys());
+		const fullRebuild = runtimeSignature !== nextSignature || candidatesByFile.size === 0;
+		if (runtimeSignature !== nextSignature) {
+			debug$1("runtime signature changed, reset incremental runtime set: %s", nextSignature);
+			await reset();
+		}
+		runtimeSignature = nextSignature;
+		for (const [file, previousCandidates] of candidatesByFile) {
+			if (currentRuntimeFiles.has(file)) continue;
+			removeCandidateSet$1(candidateCountByClass, runtimeSet, previousCandidates);
+			candidatesByFile.delete(file);
+		}
+		const changedRuntimeFiles = fullRebuild ? [...runtimeEntriesByFile.keys()] : [...collectChangedRuntimeFiles(snapshot)];
+		if (changedRuntimeFiles.length === 0) return new Set(runtimeSet);
+		const rawCandidatesByFile = /* @__PURE__ */ new Map();
+		const unknownCandidates = /* @__PURE__ */ new Set();
+		await Promise.all(changedRuntimeFiles.map(async (file) => {
+			const entry = runtimeEntriesByFile.get(file);
+			if (!entry) return;
+			const candidates = await extractEntryRawCandidates(entry);
+			rawCandidatesByFile.set(file, candidates);
+			for (const candidate of candidates) if (!candidateValidityCache.has(candidate)) unknownCandidates.add(candidate);
+		}));
+		await validateUnknownCandidates(patcher, unknownCandidates);
+		let rawCandidateCount = 0;
+		for (const file of changedRuntimeFiles) {
+			const nextRawCandidates = rawCandidatesByFile.get(file);
+			const previousCandidates = candidatesByFile.get(file);
+			if (previousCandidates) removeCandidateSet$1(candidateCountByClass, runtimeSet, previousCandidates);
+			if (!nextRawCandidates || nextRawCandidates.size === 0) {
+				candidatesByFile.delete(file);
+				continue;
+			}
+			rawCandidateCount += nextRawCandidates.size;
+			const nextCandidates = new Set([...nextRawCandidates].filter((candidate) => candidateValidityCache.get(candidate) === true));
+			if (nextCandidates.size === 0) {
+				candidatesByFile.delete(file);
+				continue;
+			}
+			addCandidateSet$1(candidateCountByClass, runtimeSet, nextCandidates);
+			candidatesByFile.set(file, nextCandidates);
+		}
+		debug$1("incremental runtime set synced, changedFiles=%d rawCandidates=%d validateMisses=%d runtimeSize=%d trackedFiles=%d", changedRuntimeFiles.length, rawCandidateCount, unknownCandidates.size, runtimeSet.size, candidatesByFile.size);
+		return new Set(runtimeSet);
+	}
+	return {
+		sync,
+		reset
+	};
+}
+//#endregion
+//#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 = node_path.default.join(root, "manifest.json");
+	if (!(0, node_fs.existsSync)(manifestPath)) return;
+	try {
+		return JSON.parse((0, node_fs.readFileSync)(manifestPath, "utf8"));
+	} catch {}
+}
+function tryReadPackageJson(root) {
+	const packageJsonPath = node_path.default.join(root, PACKAGE_JSON_FILE$1);
+	if (!(0, node_fs.existsSync)(packageJsonPath)) return;
+	try {
+		return JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf8"));
+	} catch {}
+}
+function resolveAppTypeFromMarkers(root) {
+	for (const [relativePath, appType] of TAILWINDCSS_VITE_MARKERS) if ((0, node_fs.existsSync)(node_path.default.join(root, relativePath))) return appType;
+}
+function resolveImplicitAppTypeFromViteRoot(root) {
+	const resolvedRoot = node_path.default.resolve(root);
+	if (!(0, node_fs.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 = node_path.default.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+}
+//#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 = (0, _weapp_tailwindcss_shared.cleanUrl)(importer);
+	return isCSSRequest(normalized) || normalized.endsWith("/*");
+}
+function createRewriteCssImportsPlugins(options) {
+	if (!options.shouldRewrite) return [];
+	const { appType, getAppType, rootImport, weappTailwindcssDirPosix } = options;
+	const resolveAppType = () => getAppType?.() ?? appType;
+	return [{
+		name: `${require_recorder.vitePluginName}:rewrite-css-imports`,
+		enforce: "pre",
+		resolveId: {
+			order: "pre",
+			handler(id, importer) {
+				const replacement = require_css_imports.resolveTailwindcssImport(id, weappTailwindcssDirPosix, {
+					join: joinPosixPath,
+					appType: resolveAppType(),
+					rootImport
+				});
+				if (!replacement) return null;
+				if (importer && !isCssLikeImporter(importer)) return null;
+				return replacement;
+			}
+		},
+		transform: {
+			order: "pre",
+			handler(code, id) {
+				if (!isCSSRequest(id)) return null;
+				const rewritten = require_css_imports.rewriteTailwindcssImportsInCode(code, weappTailwindcssDirPosix, {
+					join: joinPosixPath,
+					appType: resolveAppType(),
+					rootImport
+				});
+				if (!rewritten) return null;
+				return {
+					code: rewritten,
+					map: null
+				};
+			}
+		}
+	}];
+}
+//#endregion
+//#region src/bundlers/vite/source-candidates.ts
+const CLEAN_URL_RE = /[?#].*$/;
+const SOURCE_CANDIDATE_EXTENSIONS = [
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts",
+	"vue",
+	"uvue",
+	"nvue",
+	"svelte",
+	"mpx",
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"css",
+	"wxss",
+	"acss",
+	"jxss",
+	"ttss",
+	"qss",
+	"tyss",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+];
+const SOURCE_CANDIDATE_EXTENSION_RE = /\.(?:[cm]?[jt]sx?|vue|uvue|nvue|svelte|mpx|html|wxml|axml|jxml|ksml|ttml|qml|tyml|xhsml|swan|css|wxss|acss|jxss|ttss|qss|tyss|scss|sass|less|stylus?)$/;
+const CSS_SOURCE_CANDIDATE_EXTENSION_RE = /^(?:css|wxss|acss|jxss|ttss|qss|tyss|scss|sass|less|styl|stylus)$/;
+const SOURCE_CANDIDATE_GLOB = `**/*.{${SOURCE_CANDIDATE_EXTENSIONS.join(",")}}`;
+const DEFAULT_SCAN_IGNORE = ["**/node_modules/**", "**/.git/**"];
+function cleanUrl(id) {
+	return id.replace(CLEAN_URL_RE, "");
+}
+function toPosixPath(value) {
+	return value.split(node_path.default.sep).join("/");
+}
+function resolveOutDirIgnorePattern(root, outDir) {
+	if (!outDir) return;
+	const relative = node_path.default.relative(root, node_path.default.resolve(root, outDir));
+	if (!relative || relative.startsWith("..") || node_path.default.isAbsolute(relative)) return;
+	return `${toPosixPath(relative)}/**`;
+}
+function resolveSourceCandidateExtension(id) {
+	const normalized = cleanUrl(id);
+	return /\.([^.\\/]+)$/.exec(normalized)?.[1] ?? "html";
+}
+function isSourceCandidateRequest(id) {
+	return SOURCE_CANDIDATE_EXTENSION_RE.test(cleanUrl(id));
+}
+function removeCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) {
+		const count = candidateCount.get(candidate);
+		if (count == null) continue;
+		if (count <= 1) {
+			candidateCount.delete(candidate);
+			continue;
+		}
+		candidateCount.set(candidate, count - 1);
+	}
+}
+function addCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) candidateCount.set(candidate, (candidateCount.get(candidate) ?? 0) + 1);
+}
+const CSS_APPLY_RE = /@apply\s+([^;{}]+)/g;
+const CSS_APPLY_IMPORTANT = "!important";
+function extractCssApplyCandidates(source) {
+	const candidates = /* @__PURE__ */ new Set();
+	CSS_APPLY_RE.lastIndex = 0;
+	let match = CSS_APPLY_RE.exec(source);
+	while (match !== null) {
+		const params = match[1] ?? "";
+		for (const candidate of (0, _weapp_tailwindcss_shared_extractors.splitCode)(params, true)) {
+			const normalized = candidate.trim();
+			if (normalized && normalized !== CSS_APPLY_IMPORTANT) candidates.add(normalized);
+		}
+		match = CSS_APPLY_RE.exec(source);
+	}
+	return candidates;
+}
+function createSourceCandidateCollector() {
+	const candidatesById = /* @__PURE__ */ new Map();
+	const candidateCount = /* @__PURE__ */ new Map();
+	async function sync(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const nextCandidates = /* @__PURE__ */ new Set();
+		if (CSS_SOURCE_CANDIDATE_EXTENSION_RE.test(extension)) for (const candidate of extractCssApplyCandidates(source)) nextCandidates.add(candidate);
+		else {
+			const matches = await (0, tailwindcss_patch.extractRawCandidatesWithPositions)(source, extension);
+			for (const match of matches) {
+				const candidate = match.rawCandidate;
+				if (typeof candidate === "string" && candidate.length > 0) nextCandidates.add(candidate);
+			}
+		}
+		remove(normalizedId);
+		if (nextCandidates.size === 0) return;
+		candidatesById.set(normalizedId, nextCandidates);
+		addCandidateSet(candidateCount, nextCandidates);
+	}
+	async function syncFile(id) {
+		const normalizedId = cleanUrl(id);
+		await sync(normalizedId, await (0, node_fs_promises.readFile)(normalizedId, "utf8"));
+	}
+	async function scanRoot({ root, outDir }) {
+		const resolvedRoot = node_path.default.resolve(root);
+		const outDirIgnore = resolveOutDirIgnorePattern(resolvedRoot, outDir);
+		const files = await (0, fast_glob.default)(SOURCE_CANDIDATE_GLOB, {
+			absolute: true,
+			cwd: resolvedRoot,
+			ignore: outDirIgnore ? [...DEFAULT_SCAN_IGNORE, outDirIgnore] : DEFAULT_SCAN_IGNORE,
+			onlyFiles: true,
+			unique: true
+		});
+		await Promise.all(files.map((file) => syncFile(file)));
+	}
+	function remove(id) {
+		const normalizedId = cleanUrl(id);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (!previousCandidates) return;
+		removeCandidateSet(candidateCount, previousCandidates);
+		candidatesById.delete(normalizedId);
+	}
+	function values() {
+		return new Set(candidateCount.keys());
+	}
+	function clear() {
+		candidatesById.clear();
+		candidateCount.clear();
+	}
+	return {
+		sync,
+		syncFile,
+		scanRoot,
+		remove,
+		values,
+		clear
+	};
+}
+//#endregion
+//#region src/bundlers/vite/index.ts
+const debug = require_recorder.createDebug();
+const weappTailwindcssPackageDir = require_css_imports.resolvePackageDir("weapp-tailwindcss");
+const weappTailwindcssDirPosix = slash(weappTailwindcssPackageDir);
+const PACKAGE_JSON_FILE = "package.json";
+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;
+}
+async function resolveFilteredPostcssConfig(root) {
+	try {
+		const loaded = await (0, postcss_load_config.default)({}, 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;
+	}
+}
+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;
+}
+function resolveImplicitTailwindcssBasedirFromViteRoot(root) {
+	const resolvedRoot = node_path.default.resolve(root);
+	if (!(0, node_fs.existsSync)(resolvedRoot)) return resolvedRoot;
+	const searchRoots = [];
+	let current = resolvedRoot;
+	while (true) {
+		searchRoots.push(current);
+		const parent = node_path.default.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	const tailwindConfigPath = require_logger.findTailwindConfig(searchRoots);
+	if (tailwindConfigPath) return node_path.default.dirname(tailwindConfigPath);
+	const packageRoot = require_logger.findNearestPackageRoot(resolvedRoot);
+	if (packageRoot && (0, node_fs.existsSync)(node_path.default.join(packageRoot, PACKAGE_JSON_FILE))) return packageRoot;
+	return resolvedRoot;
+}
+/**
+* @name UnifiedViteWeappTailwindcssPlugin
+* @description uni-app vite / uni-app-x 版本插件
+* @link https://tw.icebreaker.top/docs/quick-start/frameworks/uni-app-vite
+*/
+function UnifiedViteWeappTailwindcssPlugin(options = {}) {
+	const hasExplicitAppType = typeof options.appType === "string" && options.appType.trim().length > 0;
+	const rewriteCssImportsSpecified = Object.hasOwn(options, "rewriteCssImports");
+	const hasExplicitTailwindcssBasedir = typeof options.tailwindcssBasedir === "string" && options.tailwindcssBasedir.trim().length > 0;
+	const opts = require_recorder.getCompilerContext(options);
+	const { disabled, customAttributes, onLoad, mainCssChunkMatcher, styleHandler, jsHandler, twPatcher: initialTwPatcher, refreshTailwindcssPatcher, uniAppX, disabledDefaultTemplateHandler } = opts;
+	const uniAppXEnabled = require_logger.isUniAppXEnabled(uniAppX);
+	const disabledOptions = require_css_imports.resolveDisabledOptions(disabled);
+	const tailwindcssMajorVersion = initialTwPatcher.majorVersion ?? 0;
+	const shouldOwnTailwindGeneration = require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator).mode === "force";
+	const shouldRewriteCssImports = opts.rewriteCssImports !== false && !disabledOptions.rewriteCssImports && (rewriteCssImportsSpecified || tailwindcssMajorVersion >= 4);
+	const rewritePlugins = createRewriteCssImportsPlugins({
+		getAppType: () => opts.appType,
+		rootImport: shouldOwnTailwindGeneration ? `${weappTailwindcssDirPosix}/generator-placeholder.css` : void 0,
+		shouldRewrite: shouldRewriteCssImports,
+		weappTailwindcssDirPosix
+	});
+	if (disabledOptions.plugin) return rewritePlugins.length ? rewritePlugins : void 0;
+	const customAttributesEntities = require_recorder.toCustomAttributesEntities(customAttributes);
+	const patchRecorderState = require_recorder.setupPatchRecorder(initialTwPatcher, opts.tailwindcssBasedir, {
+		source: "runtime",
+		cwd: opts.tailwindcssBasedir ?? node_process.default.cwd()
+	});
+	const runtimeState = {
+		twPatcher: initialTwPatcher,
+		patchPromise: patchRecorderState.patchPromise,
+		refreshTailwindcssPatcher,
+		onPatchCompleted: patchRecorderState.onPatchCompleted
+	};
+	let runtimeSet;
+	let runtimeSetPromise;
+	let resolvedConfig;
+	let runtimeRefreshSignature;
+	let runtimeRefreshOptionsKey;
+	let recordedGeneratorCandidates;
+	const bundleRuntimeClassSetManager = createBundleRuntimeClassSetManager();
+	const sourceCandidateCollector = createSourceCandidateCollector();
+	const pendingSourceCandidateSyncs = /* @__PURE__ */ new Set();
+	const processedCssAssets = /* @__PURE__ */ new WeakSet();
+	const processedCssAssetFiles = /* @__PURE__ */ new Set();
+	const rememberedMainCssSources = /* @__PURE__ */ new Map();
+	const rememberedMainCssSignatureByFile = /* @__PURE__ */ new Map();
+	function resolveRuntimeRefreshOptions() {
+		const configPath = require_patcher_options.resolveTailwindcssOptions(runtimeState.twPatcher.options)?.config;
+		const signature = require_logger.getRuntimeClassSetSignature(runtimeState.twPatcher);
+		const optionsKey = JSON.stringify({
+			appType: opts.appType,
+			uniAppX: uniAppXEnabled,
+			customAttributesEntities,
+			disabledDefaultTemplateHandler,
+			configPath,
+			rewriteCssImports: shouldRewriteCssImports
+		});
+		const changed = signature !== runtimeRefreshSignature || optionsKey !== runtimeRefreshOptionsKey;
+		runtimeRefreshSignature = signature;
+		runtimeRefreshOptionsKey = optionsKey;
+		return {
+			changed,
+			signature,
+			optionsKey
+		};
+	}
+	async function refreshRuntimeState(force) {
+		const invalidation = resolveRuntimeRefreshOptions();
+		const refreshed = await require_recorder.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 || node_process.default.env.WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH === "1";
+		await refreshRuntimeState(force);
+		await runtimeState.patchPromise;
+		if (!forceRuntimeRefresh && runtimeSet) return runtimeSet;
+		if (forceRuntimeRefresh || !runtimeSetPromise) {
+			const invalidation = resolveRuntimeRefreshOptions();
+			runtimeSetPromise = require_recorder.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) {
+		const forceRuntimeRefresh = forceRefresh || node_process.default.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.patchPromise;
+		if (shouldRefreshPatcher) {
+			runtimeSet = void 0;
+			runtimeSetPromise = void 0;
+			await bundleRuntimeClassSetManager.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 (!forceRuntimeRefresh && !invalidation.changed && !forceCollectBySource && runtimeSet) return runtimeSet;
+		const task = require_recorder.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;
+		}
+	}
+	onLoad();
+	const getResolvedConfig = () => resolvedConfig;
+	const markCssAssetProcessed = (asset, file) => {
+		processedCssAssets.add(asset);
+		if (file) processedCssAssetFiles.add(require_css_imports.normalizeOutputPathKey(file));
+	};
+	const isCssAssetProcessed = (asset, file) => {
+		return processedCssAssets.has(asset) || (file ? processedCssAssetFiles.has(require_css_imports.normalizeOutputPathKey(file)) : false);
+	};
+	const recordGeneratorCandidates = (candidates) => {
+		recordedGeneratorCandidates = new Set(candidates);
+	};
+	const getRecordedGeneratorCandidates = () => recordedGeneratorCandidates;
+	const getSourceCandidates = () => sourceCandidateCollector.values();
+	const isWatchBuild = () => resolvedConfig?.command === "build" && resolvedConfig.build.watch != null;
+	const waitForSourceCandidateSyncs = async () => {
+		while (pendingSourceCandidateSyncs.size > 0) await Promise.all(pendingSourceCandidateSyncs);
+	};
+	const syncChangedSourceCandidateFile = (id) => {
+		if (!shouldOwnTailwindGeneration || !isSourceCandidateRequest(id)) return Promise.resolve();
+		const task = sourceCandidateCollector.syncFile(id).catch((error) => {
+			debug("source candidate watch sync failed: %s %O", id, error);
+		}).finally(() => {
+			pendingSourceCandidateSyncs.delete(task);
+		});
+		pendingSourceCandidateSyncs.add(task);
+		return task;
+	};
+	const rememberMainCssSource = (file, rawSource, cssRuntimeSignature) => {
+		rememberedMainCssSources.set(file, rawSource);
+		if (cssRuntimeSignature) rememberedMainCssSignatureByFile.set(file, cssRuntimeSignature);
+	};
+	const getRememberedMainCssSources = () => rememberedMainCssSources;
+	const getRememberedMainCssSignature = (file) => rememberedMainCssSignatureByFile.get(file);
+	const setRememberedMainCssSignature = (file, cssRuntimeSignature) => {
+		rememberedMainCssSignatureByFile.set(file, cssRuntimeSignature);
+	};
+	const cssFinalizerOutputPlugin = createViteCssFinalizerOutputPlugin({
+		opts,
+		runtimeState,
+		ensureRuntimeClassSet,
+		debug,
+		getResolvedConfig,
+		markCssAssetProcessed,
+		isCssAssetProcessed,
+		getRecordedGeneratorCandidates,
+		getSourceCandidates,
+		waitForSourceCandidateSyncs,
+		rememberMainCssSource
+	});
+	const isIosPlatform = require_utils.resolveUniUtsPlatform().isAppIos;
+	const uniAppXPlugins = uniAppXEnabled ? createUniAppXPlugins({
+		appType: opts.appType ?? "uni-app-x",
+		customAttributesEntities,
+		disabledDefaultTemplateHandler,
+		isIosPlatform,
+		mainCssChunkMatcher,
+		runtimeState,
+		styleHandler,
+		jsHandler,
+		ensureRuntimeClassSet,
+		getResolvedConfig,
+		uniAppX
+	}) : void 0;
+	const plugins = [
+		...rewritePlugins,
+		{
+			name: `${require_recorder.vitePluginName}:source-candidates`,
+			enforce: "pre",
+			async transform(code, id) {
+				if (!shouldOwnTailwindGeneration || !isSourceCandidateRequest(id)) return;
+				await sourceCandidateCollector.sync(id, code);
+			},
+			async watchChange(id, change) {
+				if (change.event === "delete") {
+					sourceCandidateCollector.remove(id);
+					return;
+				}
+				await syncChangedSourceCandidateFile(id);
+			},
+			async handleHotUpdate(ctx) {
+				await syncChangedSourceCandidateFile(ctx.file);
+			},
+			async buildStart() {
+				if (!shouldOwnTailwindGeneration) return;
+				if (resolvedConfig?.command === "build" && !isWatchBuild()) sourceCandidateCollector.clear();
+				const root = resolvedConfig?.root ?? node_process.default.cwd();
+				const outDir = resolvedConfig?.build?.outDir;
+				await sourceCandidateCollector.scanRoot({
+					root,
+					outDir
+				});
+			}
+		},
+		{
+			name: `${require_recorder.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 ? node_path.default.resolve(config.root) : node_process.default.cwd();
+				const baseConfig = { resolve: { alias: [{
+					find: /^tailwindcss$/,
+					replacement: node_path.default.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) {
+				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 ? node_path.default.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 (!hasExplicitAppType && resolvedRoot) {
+					const nextAppType = resolveImplicitAppTypeFromViteRoot(resolvedRoot);
+					if (nextAppType && opts.appType !== nextAppType) {
+						const previousAppType = opts.appType;
+						opts.appType = nextAppType;
+						_weapp_tailwindcss_logger.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, (0, _weapp_tailwindcss_postcss_html_transform.default)());
+						debug("remove postcss-html-transform plugin from vite config");
+					}
+				}
+			},
+			generateBundle: {
+				order: "post",
+				handler: createGenerateBundleHook({
+					opts,
+					runtimeState,
+					ensureRuntimeClassSet,
+					ensureBundleRuntimeClassSet,
+					debug,
+					getResolvedConfig,
+					markCssAssetProcessed,
+					getSourceCandidates,
+					waitForSourceCandidateSyncs,
+					rememberMainCssSource,
+					getRememberedMainCssSources,
+					getRememberedMainCssSignature,
+					setRememberedMainCssSignature,
+					recordGeneratorCandidates
+				})
+			},
+			outputOptions(options) {
+				const plugins = options.plugins;
+				return {
+					...options,
+					plugins: Array.isArray(plugins) ? [...plugins, cssFinalizerOutputPlugin] : [cssFinalizerOutputPlugin]
+				};
+			}
+		}
+	];
+	if (uniAppXPlugins) plugins.push(...uniAppXPlugins);
+	return plugins;
+}
+//#endregion
+Object.defineProperty(exports, "UnifiedViteWeappTailwindcssPlugin", {
+	enumerable: true,
+	get: function() {
+		return UnifiedViteWeappTailwindcssPlugin;
+	}
+});