weapp-tailwindcss 5.4.2 → 5.5.1

package/dist/web-B2Ea9K4B.cjs

@@ -0,0 +1,4361 @@
+const require_rolldown_runtime = require("./rolldown-runtime-Ctb5zv51.cjs");
+const require_framework = require("./framework.cjs");
+const require_generator = require("./generator-DsrQ9txU.cjs");
+const require_tailwindcss = require("./tailwindcss-C-jBBQfw.cjs");
+const require_v4_generation_core = require("./v4-generation-core-CRNUU_Rr.cjs");
+const require_compiler = require("./compiler-D2ZJc3uA.cjs");
+const require_runtime_state = require("./runtime-state-BBQcA0n5.cjs");
+const require_hmr_timing = require("./hmr-timing-Cz4IesEM.cjs");
+const require_source_candidate_scan_signature = require("./source-candidate-scan-signature-B7cUxqqX.cjs");
+const require_css_imports = require("./css-imports-BFMU7Hpd.cjs");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path, 1);
+let node_process = require("node:process");
+node_process = require_rolldown_runtime.__toESM(node_process, 1);
+let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
+let lru_cache = require("lru-cache");
+let node_fs_promises = require("node:fs/promises");
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
+let node_url = require("node:url");
+let weapp_style_injector_vite = require("weapp-style-injector/vite");
+let node_async_hooks = require("node:async_hooks");
+//#region src/bundlers/vite/capability-profile.ts
+const frameworkViteCapabilityProfile = {
+	name: "framework",
+	frameworkName: "generic",
+	generatorTarget: void 0,
+	platformFamily: "unknown",
+	sourceCandidates: true,
+	frameworkExtras: true,
+	serveJsTransform: true,
+	styleInjector: true
+};
+function createGenericWebViteCapabilityProfile(options) {
+	return {
+		name: "generic-web",
+		cssOnly: true,
+		frameworkName: "generic",
+		generatorTarget: "web",
+		platformFamily: "web",
+		sourceCandidates: options.cssSourceTrace === true || typeof options.cssSourceTrace === "object",
+		frameworkExtras: false,
+		serveJsTransform: false,
+		styleInjector: options.styleInjector !== void 0
+	};
+}
+//#endregion
+//#region src/bundlers/vite/source-output-relations.ts
+const activeRelationOwnerStorage = new node_async_hooks.AsyncLocalStorage();
+function normalizeSourceFile(sourceFile) {
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(sourceFile.replace(/[?#].*$/, ""));
+}
+function normalizeOutputFile(outputFile) {
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(outputFile);
+}
+function collectOwnedSources(output) {
+	if (output.type === "chunk") {
+		if (output.facadeModuleId) return [output.facadeModuleId];
+		const moduleIds = Array.isArray(output.moduleIds) ? output.moduleIds : [];
+		return moduleIds.length === 1 ? moduleIds : [];
+	}
+	return [output.originalFileName, ...Array.isArray(output.originalFileNames) ? output.originalFileNames : []].filter((sourceFile) => typeof sourceFile === "string" && sourceFile.length > 0);
+}
+function createViteSourceOutputRelationOwner() {
+	const outputsBySource = /* @__PURE__ */ new Map();
+	const sourcesByOutput = /* @__PURE__ */ new Map();
+	const deletedSources = /* @__PURE__ */ new Set();
+	const dirtySources = /* @__PURE__ */ new Set();
+	const consumers = /* @__PURE__ */ new Set();
+	let disposed = false;
+	const unlinkSourceFromOutput = (sourceFile, outputFile) => {
+		const outputs = outputsBySource.get(sourceFile);
+		outputs?.delete(outputFile);
+		if (outputs?.size === 0) outputsBySource.delete(sourceFile);
+		const sources = sourcesByOutput.get(outputFile);
+		sources?.delete(sourceFile);
+		if (sources?.size === 0) sourcesByOutput.delete(outputFile);
+	};
+	const unlinkSource = (sourceFile) => {
+		const outputs = [...outputsBySource.get(sourceFile) ?? []];
+		for (const outputFile of outputs) unlinkSourceFromOutput(sourceFile, outputFile);
+		return outputs;
+	};
+	const queueRemovedOutputs = (outputFiles) => {
+		for (const outputFile of outputFiles) {
+			if (sourcesByOutput.has(outputFile)) continue;
+			for (const consumer of consumers) consumer.pending.add(outputFile);
+		}
+	};
+	const recordOwnedOutput = (sourceFile, outputFile) => {
+		if (disposed) return;
+		const sourceKey = normalizeSourceFile(sourceFile);
+		const outputKey = normalizeOutputFile(outputFile);
+		if (!sourceKey || !outputKey || deletedSources.has(sourceKey)) return;
+		if (dirtySources.delete(sourceKey)) queueRemovedOutputs(unlinkSource(sourceKey));
+		const outputs = outputsBySource.get(sourceKey) ?? /* @__PURE__ */ new Set();
+		outputs.add(outputKey);
+		outputsBySource.set(sourceKey, outputs);
+		const sources = sourcesByOutput.get(outputKey) ?? /* @__PURE__ */ new Set();
+		sources.add(sourceKey);
+		sourcesByOutput.set(outputKey, sources);
+	};
+	const replaceOutputOwners = (outputFile, sourceFiles) => {
+		const outputKey = normalizeOutputFile(outputFile);
+		for (const sourceFile of [...sourcesByOutput.get(outputKey) ?? []]) unlinkSourceFromOutput(sourceFile, outputKey);
+		for (const sourceFile of sourceFiles) {
+			deletedSources.delete(normalizeSourceFile(sourceFile));
+			recordOwnedOutput(sourceFile, outputKey);
+		}
+	};
+	return {
+		createRemovalConsumer() {
+			const state = { pending: /* @__PURE__ */ new Set() };
+			consumers.add(state);
+			return { consume(currentBundleFiles) {
+				if (disposed || state.pending.size === 0) return [];
+				const currentFiles = new Set([...currentBundleFiles].map(normalizeOutputFile));
+				const removedFiles = [...state.pending].filter((file) => !currentFiles.has(file));
+				state.pending.clear();
+				return removedFiles;
+			} };
+		},
+		dispose() {
+			disposed = true;
+			outputsBySource.clear();
+			sourcesByOutput.clear();
+			deletedSources.clear();
+			dirtySources.clear();
+			consumers.clear();
+		},
+		getStats() {
+			return {
+				consumers: consumers.size,
+				dirtySources: dirtySources.size,
+				outputs: sourcesByOutput.size,
+				pendingOutputs: new Set([...consumers].flatMap((consumer) => [...consumer.pending])).size,
+				sources: outputsBySource.size
+			};
+		},
+		getOutputSources(outputFile) {
+			return new Set(sourcesByOutput.get(normalizeOutputFile(outputFile)) ?? []);
+		},
+		getOwnedOutputs(sourceFile) {
+			return new Set(outputsBySource.get(normalizeSourceFile(sourceFile)) ?? []);
+		},
+		observeSource(sourceFile) {
+			if (!disposed) {
+				const sourceKey = normalizeSourceFile(sourceFile);
+				deletedSources.delete(sourceKey);
+				if (outputsBySource.has(sourceKey)) dirtySources.add(sourceKey);
+			}
+		},
+		recordBundle(bundle) {
+			if (disposed) return;
+			for (const [bundleFile, output] of Object.entries(bundle)) {
+				const ownedSources = collectOwnedSources(output);
+				if (ownedSources.length > 0) replaceOutputOwners(output.fileName || bundleFile, ownedSources);
+			}
+		},
+		recordOwnedOutput,
+		removeSource(sourceFile) {
+			if (disposed) return /* @__PURE__ */ new Set();
+			const sourceKey = normalizeSourceFile(sourceFile);
+			deletedSources.add(sourceKey);
+			dirtySources.delete(sourceKey);
+			const removedOutputs = /* @__PURE__ */ new Set();
+			for (const outputFile of unlinkSource(sourceKey)) if (!sourcesByOutput.has(outputFile)) removedOutputs.add(outputFile);
+			queueRemovedOutputs(removedOutputs);
+			return removedOutputs;
+		}
+	};
+}
+function getActiveViteSourceOutputRelationOwner() {
+	return activeRelationOwnerStorage.getStore();
+}
+function withViteSourceOutputRelationOwner(owner, run) {
+	return activeRelationOwnerStorage.run(owner, run);
+}
+//#endregion
+//#region src/bundlers/vite/css-asset-identity.ts
+function createViteCssAssetIdentityResolver(options) {
+	const identityByAsset = /* @__PURE__ */ new WeakMap();
+	const placeholderFile = require_source_candidate_scan_signature.normalizeOutputPathKey(node_path.default.resolve(options.generatorPlaceholderFile));
+	return (asset, file) => {
+		const cached = identityByAsset.get(asset);
+		if (cached) return cached;
+		const candidates = [
+			file,
+			asset.originalFileName,
+			...asset.originalFileNames ?? []
+		].filter((candidate) => typeof candidate === "string" && candidate.length > 0);
+		const placeholderSourceFile = candidates.find((candidate) => require_source_candidate_scan_signature.normalizeOutputPathKey(node_path.default.resolve(candidate.replace(/[?#].*$/, ""))) === placeholderFile);
+		let identity;
+		if (placeholderSourceFile) identity = {
+			kind: "generator-placeholder",
+			sourceFile: placeholderSourceFile
+		};
+		else {
+			const processedSourceFile = candidates.find(options.isKnownProcessedSource);
+			identity = processedSourceFile ? {
+				kind: "bundler-generated",
+				sourceFile: processedSourceFile
+			} : { kind: "user" };
+		}
+		identityByAsset.set(asset, identity);
+		return identity;
+	};
+}
+//#endregion
+//#region src/bundlers/vite/css-handler-options.ts
+function resolveViteCssHandlerExtraOptions(file) {
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(file.replace(/[?#].*$/, "")).includes("/") ? { isMainChunk: false } : {};
+}
+function createCssHandlerOptionsCache(options) {
+	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+	const cssUserHandlerOptionsCache = /* @__PURE__ */ new Map();
+	const getCssHandlerOptions = (file) => {
+		const majorVersion = options.getMajorVersion();
+		const appType = options.getAppType();
+		const isMainChunk = options.mainCssChunkMatcher(file, appType);
+		const outputRoot = options.getOutputRoot?.();
+		const sourceFile = require_v4_generation_core.stripRequestQuery(file);
+		const from = node_path.default.isAbsolute(sourceFile) ? sourceFile : outputRoot ? node_path.default.resolve(outputRoot, sourceFile) : sourceFile;
+		const extraOptions = options.getExtraOptions?.(file) ?? {};
+		const dynamicCssOptions = options.getDynamicCssOptions?.() ?? {};
+		const cacheKey = `${majorVersion ?? "unknown"}:${appType ?? "unknown"}:${isMainChunk ? "1" : "0"}:${outputRoot ?? ""}:${file}:${JSON.stringify(extraOptions)}:${JSON.stringify(dynamicCssOptions)}`;
+		const cached = cssHandlerOptionsCache.get(cacheKey);
+		if (cached) return cached;
+		const created = {
+			isMainChunk,
+			...extraOptions,
+			...dynamicCssOptions,
+			postcssOptions: { options: { from } },
+			majorVersion: require_compiler.normalizeStyleHandlerMajorVersion(majorVersion),
+			sourceOptions: {
+				outputRoot,
+				...sourceFile === file ? {} : { requestFile: file }
+			}
+		};
+		cssHandlerOptionsCache.set(cacheKey, created);
+		return created;
+	};
+	const getCssUserHandlerOptions = (file) => {
+		const majorVersion = options.getMajorVersion();
+		const outputRoot = options.getOutputRoot?.();
+		const cacheKey = `${majorVersion ?? "unknown"}:${outputRoot ?? ""}:${file}`;
+		const cached = cssUserHandlerOptionsCache.get(cacheKey);
+		if (cached) return cached;
+		const created = {
+			...getCssHandlerOptions(file),
+			isMainChunk: false
+		};
+		cssUserHandlerOptionsCache.set(cacheKey, created);
+		return created;
+	};
+	return {
+		getCssHandlerOptions,
+		getCssUserHandlerOptions
+	};
+}
+//#endregion
+//#region src/bundlers/vite/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)(?:$|\\?)`);
+const htmlLangRE = /\.html?(?:$|\?)/;
+function isCSSRequest(request) {
+	return cssLangRE.test(request) || require_v4_generation_core.isSourceStyleRequest(request);
+}
+function isWeappViteSidecarRequest(request) {
+	const queryIndex = request.indexOf("?");
+	if (queryIndex < 0) return false;
+	const hashIndex = request.indexOf("#", queryIndex);
+	const query = request.slice(queryIndex + 1, hashIndex < 0 ? void 0 : hashIndex);
+	return new URLSearchParams(query).has("weapp-vite-sidecar");
+}
+function resolveViteCssPipelineRequestFile(request) {
+	return isWeappViteSidecarRequest(request) ? (0, _weapp_tailwindcss_shared.cleanUrl)(request) : request;
+}
+function isHTMLRequest(request) {
+	return htmlLangRE.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/bundlers/vite/css-output.ts
+const SOURCE_STYLE_OUTPUT_EXT_RE = /\.(?:less|sass|scss|styl|stylus|pcss|postcss)$/i;
+const CSS_SOURCE_OUTPUT_EXT_RE = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)$/i;
+const SOURCE_STYLE_NON_CSS_SYNTAX_RE = /(?:^|\n)\s*(?:\/\/|\$[\w-]+\s*:|@(?:use|forward|mixin|include|function)\b)/;
+const FALLBACK_STYLE_OUTPUT_EXTENSION = ".css";
+const COMMON_MINI_PROGRAM_STYLE_OUTPUT_EXTENSIONS = [
+	".wxss",
+	".acss",
+	".ttss",
+	".qss",
+	".jxss",
+	".tyss"
+];
+function resolveCssOutputRealPath(value) {
+	const resolved = node_path.default.resolve(value);
+	let current = resolved;
+	const pendingSegments = [];
+	while (!(0, node_fs.existsSync)(current)) {
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return resolved;
+		pendingSegments.unshift(node_path.default.basename(current));
+		current = parent;
+	}
+	try {
+		const realPath = node_fs.realpathSync.native(current);
+		return pendingSegments.length > 0 ? node_path.default.join(realPath, ...pendingSegments) : realPath;
+	} catch {
+		return resolved;
+	}
+}
+function normalizeStyleOutputExtension(value) {
+	if (typeof value !== "string" || value.trim().length === 0) return;
+	const normalized = value.trim().toLowerCase();
+	return normalized.startsWith(".") ? normalized : `.${normalized}`;
+}
+function getMatchedStyleOutputExtension(file, cssMatcher) {
+	const cleanFile = file.replace(/[?#].*$/, "");
+	if (!cssMatcher?.(cleanFile)) return;
+	const ext = node_path.default.extname(cleanFile);
+	if (!ext || ext === ".css") return;
+	return ext;
+}
+function resolveStyleOutputExtensionFromFiles(files, cssMatcher, stem) {
+	let extension;
+	for (const file of files ?? []) {
+		const cleanFile = file.replace(/[?#].*$/, "");
+		const matchedExtension = getMatchedStyleOutputExtension(cleanFile, cssMatcher);
+		if (!matchedExtension) continue;
+		if (stem && cleanFile.slice(0, -matchedExtension.length) !== stem) continue;
+		if (extension && extension !== matchedExtension) return;
+		extension = matchedExtension;
+	}
+	return extension;
+}
+function resolveStyleOutputExtensionFromMatcher(cssMatcher, stem) {
+	if (!cssMatcher || !stem) return;
+	return COMMON_MINI_PROGRAM_STYLE_OUTPUT_EXTENSIONS.find((extension) => cssMatcher(`${stem}${extension}`));
+}
+function resolveStyleOutputFileFromFiles(files, cssMatcher, stem) {
+	const cleanStem = require_source_candidate_scan_signature.normalizeOutputPathKey(stem);
+	const stemSuffix = `/${cleanStem}`;
+	const matchedFiles = /* @__PURE__ */ new Set();
+	for (const file of files ?? []) {
+		const cleanFile = require_source_candidate_scan_signature.normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+		if (!cssMatcher?.(cleanFile)) continue;
+		const extension = node_path.default.extname(cleanFile);
+		if (!extension || extension === ".css") continue;
+		const outputStem = cleanFile.slice(0, -extension.length);
+		const outputStemSuffix = `/${outputStem}`;
+		if (outputStem === cleanStem || outputStem.endsWith(stemSuffix) || cleanStem.endsWith(outputStemSuffix) || cleanStem.endsWith(`/${outputStem}`)) matchedFiles.add(cleanFile);
+	}
+	return matchedFiles.size === 1 ? [...matchedFiles][0] : void 0;
+}
+function resolveMiniProgramStyleOutputExtension(options = {}) {
+	return resolveStyleOutputExtensionFromFiles(options.files, options.cssMatcher, options.stem) ?? resolveStyleOutputExtensionFromFiles(options.files, options.cssMatcher) ?? resolveStyleOutputExtensionFromMatcher(options.cssMatcher, options.stem) ?? normalizeStyleOutputExtension(options.fallback) ?? FALLBACK_STYLE_OUTPUT_EXTENSION;
+}
+function resolveReplayCssOutputFile(rootDir, file) {
+	const cleanFile = file.replace(/[?#].*$/, "");
+	const nextFile = node_path.default.isAbsolute(cleanFile) ? node_path.default.relative(resolveCssOutputRealPath(rootDir), resolveCssOutputRealPath(cleanFile)) : cleanFile;
+	const normalizedFile = require_source_candidate_scan_signature.normalizeOutputPathKey(nextFile);
+	if (normalizedFile.length === 0 || normalizedFile === "." || normalizedFile === ".." || normalizedFile.startsWith("../")) return require_source_candidate_scan_signature.normalizeOutputPathKey(node_path.default.basename(cleanFile));
+	return normalizedFile;
+}
+function normalizeViteSourceRoot(rootDir, sourceRoot) {
+	if (typeof sourceRoot !== "string" || sourceRoot.trim().length === 0) return;
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(node_path.default.isAbsolute(sourceRoot) ? node_path.default.relative(rootDir, sourceRoot) : sourceRoot).replace(/\/+$/, "");
+}
+function resolveReplayCssOutputFileFromSourceRoot(rootDir, file, sourceRoot) {
+	const outputFile = resolveReplayCssOutputFile(rootDir, file);
+	const normalizedSourceRoot = normalizeViteSourceRoot(rootDir, sourceRoot);
+	if (!normalizedSourceRoot) return outputFile;
+	if (outputFile === normalizedSourceRoot) return node_path.default.posix.basename(outputFile);
+	if (outputFile.startsWith(`${normalizedSourceRoot}/`)) return outputFile.slice(normalizedSourceRoot.length + 1);
+	return outputFile;
+}
+function resolveViteCssOutputFile(file, opts, isWebGeneratorTarget, preserveCssExtension = false, styleOutputExtension, styleOutputFiles) {
+	const cleanFile = file.replace(/[?#].*$/, "");
+	if (isWebGeneratorTarget || preserveCssExtension || opts.cssMatcher(cleanFile) || !CSS_SOURCE_OUTPUT_EXT_RE.test(cleanFile) || !isCSSRequest(file)) return cleanFile;
+	const stem = cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, "");
+	return cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, resolveMiniProgramStyleOutputExtension({
+		cssMatcher: opts.cssMatcher,
+		fallback: styleOutputExtension,
+		files: styleOutputFiles,
+		stem
+	}));
+}
+function resolveViteCssPipelineOutputFile(file, opts, rootDir, isWebGeneratorTarget = false, preserveCssExtension = false, sourceRoot, styleOutputExtension, styleOutputFiles) {
+	const sourceStyleRequest = isCSSRequest(file);
+	const cleanFile = resolveReplayCssOutputFileFromSourceRoot(rootDir, file, sourceRoot).replace(/[?#].*$/, "");
+	const sourceExtension = node_path.default.extname(cleanFile);
+	if (sourceStyleRequest && !isWebGeneratorTarget && !preserveCssExtension && sourceExtension.length > 0 && !CSS_SOURCE_OUTPUT_EXT_RE.test(cleanFile)) {
+		const stem = cleanFile.slice(0, -sourceExtension.length);
+		return `${stem}${resolveMiniProgramStyleOutputExtension({
+			cssMatcher: opts.cssMatcher,
+			fallback: styleOutputExtension,
+			files: styleOutputFiles,
+			stem
+		})}`;
+	}
+	const stem = cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, "");
+	const matchedStyleExtension = !isWebGeneratorTarget && !preserveCssExtension ? resolveStyleOutputExtensionFromFiles(styleOutputFiles, opts.cssMatcher, stem) : void 0;
+	if (matchedStyleExtension && CSS_SOURCE_OUTPUT_EXT_RE.test(cleanFile) && sourceStyleRequest) return cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, matchedStyleExtension);
+	if (isWebGeneratorTarget || preserveCssExtension || opts.cssMatcher(cleanFile) || !CSS_SOURCE_OUTPUT_EXT_RE.test(cleanFile) || !sourceStyleRequest) return cleanFile;
+	const fallbackExtension = normalizeStyleOutputExtension(styleOutputExtension);
+	if (!fallbackExtension && !SOURCE_STYLE_OUTPUT_EXT_RE.test(cleanFile)) return cleanFile;
+	return cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, fallbackExtension ?? FALLBACK_STYLE_OUTPUT_EXTENSION);
+}
+function resolveViteCssPipelineOutputFileFromSourceFile(sourceFile, opts, rootDir, isWebGeneratorTarget = false, preserveCssExtension = false, sourceRoot, styleOutputExtension, styleOutputFiles) {
+	const sourceStyleRequest = isCSSRequest(sourceFile);
+	const cleanFile = resolveReplayCssOutputFileFromSourceRoot(rootDir, sourceFile, sourceRoot).replace(/[?#].*$/, "");
+	const sourceExtension = node_path.default.extname(cleanFile);
+	if (sourceStyleRequest && !isWebGeneratorTarget && !preserveCssExtension && sourceExtension.length > 0 && !CSS_SOURCE_OUTPUT_EXT_RE.test(cleanFile)) {
+		const stem = cleanFile.slice(0, -sourceExtension.length);
+		return resolveStyleOutputFileFromFiles(styleOutputFiles, opts.cssMatcher, stem) ?? `${stem}${resolveMiniProgramStyleOutputExtension({
+			cssMatcher: opts.cssMatcher,
+			fallback: styleOutputExtension,
+			files: styleOutputFiles,
+			stem
+		})}`;
+	}
+	if (isWebGeneratorTarget || preserveCssExtension || !CSS_SOURCE_OUTPUT_EXT_RE.test(cleanFile) || !sourceStyleRequest) return cleanFile;
+	const stem = cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, "");
+	const matchedStyleFile = resolveStyleOutputFileFromFiles(styleOutputFiles, opts.cssMatcher, stem);
+	if (matchedStyleFile) return matchedStyleFile;
+	const styleExtension = resolveStyleOutputExtensionFromFiles(styleOutputFiles, opts.cssMatcher, stem) ?? resolveMiniProgramStyleOutputExtension({
+		cssMatcher: opts.cssMatcher,
+		fallback: styleOutputExtension,
+		files: styleOutputFiles,
+		stem
+	}) ?? normalizeStyleOutputExtension(styleOutputExtension);
+	return cleanFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, styleExtension);
+}
+function canProcessViteSourceStyleAsCss(source, file) {
+	if (SOURCE_STYLE_NON_CSS_SYNTAX_RE.test(source)) return false;
+	try {
+		_weapp_tailwindcss_postcss.postcss.parse(source, { from: file });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function normalizeCssSourceForCompare(css) {
+	return css.trim();
+}
+function stripStyleFileExtension(file) {
+	const normalized = file.replace(/[?#].*$/, "");
+	const ext = node_path.default.extname(normalized);
+	return ext ? normalized.slice(0, -ext.length) : normalized;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+let _lazyMatch = () => {
+	var __lib__ = (() => {
+		var m = Object.defineProperty, V = Object.getOwnPropertyDescriptor, G = Object.getOwnPropertyNames, T = Object.prototype.hasOwnProperty, q = (r, e) => {
+			for (var n in e) m(r, n, {
+				get: e[n],
+				enumerable: true
+			});
+		}, H = (r, e, n, a) => {
+			if (e && typeof e == "object" || typeof e == "function") for (let t of G(e)) !T.call(r, t) && t !== n && m(r, t, {
+				get: () => e[t],
+				enumerable: !(a = V(e, t)) || a.enumerable
+			});
+			return r;
+		}, J = (r) => H(m({}, "__esModule", { value: true }), r), w = {};
+		q(w, { default: () => re });
+		var A = (r) => Array.isArray(r), d = (r) => typeof r == "function", Q = (r) => r.length === 0, W = (r) => typeof r == "number", K = (r) => typeof r == "object" && r !== null, X = (r) => r instanceof RegExp, b = (r) => typeof r == "string", h = (r) => r === void 0, Y = (r) => {
+			const e = /* @__PURE__ */ new Map();
+			return (n) => {
+				const a = e.get(n);
+				if (a) return a;
+				const t = r(n);
+				return e.set(n, t), t;
+			};
+		}, rr = (r, e, n = {}) => {
+			const a = {
+				cache: {},
+				input: r,
+				index: 0,
+				indexMax: 0,
+				options: n,
+				output: []
+			};
+			if (v(e)(a) && a.index === r.length) return a.output;
+			throw new Error(`Failed to parse at index ${a.indexMax}`);
+		}, i = (r, e) => A(r) ? er(r, e) : b(r) ? ar(r, e) : nr(r, e), er = (r, e) => {
+			const n = {};
+			for (const a of r) {
+				if (a.length !== 1) throw new Error(`Invalid character: "${a}"`);
+				const t = a.charCodeAt(0);
+				n[t] = true;
+			}
+			return (a) => {
+				const t = a.index, o = a.input;
+				for (; a.index < o.length && o.charCodeAt(a.index) in n;) a.index += 1;
+				const u = a.index;
+				if (u > t) {
+					if (!h(e) && !a.options.silent) {
+						const s = a.input.slice(t, u), c = d(e) ? e(s, o, String(t)) : e;
+						h(c) || a.output.push(c);
+					}
+					a.indexMax = Math.max(a.indexMax, a.index);
+				}
+				return true;
+			};
+		}, nr = (r, e) => {
+			const n = r.source, a = r.flags.replace(/y|$/, "y"), t = new RegExp(n, a);
+			return g((o) => {
+				t.lastIndex = o.index;
+				const u = t.exec(o.input);
+				if (u) {
+					if (!h(e) && !o.options.silent) {
+						const s = d(e) ? e(...u, o.input, String(o.index)) : e;
+						h(s) || o.output.push(s);
+					}
+					return o.index += u[0].length, o.indexMax = Math.max(o.indexMax, o.index), true;
+				} else return false;
+			});
+		}, ar = (r, e) => (n) => {
+			if (n.input.startsWith(r, n.index)) {
+				if (!h(e) && !n.options.silent) {
+					const t = d(e) ? e(r, n.input, String(n.index)) : e;
+					h(t) || n.output.push(t);
+				}
+				return n.index += r.length, n.indexMax = Math.max(n.indexMax, n.index), true;
+			} else return false;
+		}, C = (r, e, n, a) => {
+			const t = v(r);
+			return g(_(M((o) => {
+				let u = 0;
+				for (; u < n;) {
+					const s = o.index;
+					if (!t(o) || (u += 1, o.index === s)) break;
+				}
+				return u >= e;
+			})));
+		}, tr = (r, e) => C(r, 0, 1), f = (r, e) => C(r, 0, 1 / 0), x = (r, e) => {
+			const n = r.map(v);
+			return g(_(M((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (!n[t](a)) return false;
+				return true;
+			})));
+		}, l = (r, e) => {
+			const n = r.map(v);
+			return g(_((a) => {
+				for (let t = 0, o = n.length; t < o; t++) if (n[t](a)) return true;
+				return false;
+			}));
+		}, M = (r, e = false) => {
+			const n = v(r);
+			return (a) => {
+				const t = a.index, o = a.output.length, u = n(a);
+				return (!u || e) && (a.index = t, a.output.length !== o && (a.output.length = o)), u;
+			};
+		}, _ = (r, e) => {
+			return v(r);
+		}, g = (() => {
+			let r = 0;
+			return (e) => {
+				const n = v(e), a = r += 1;
+				return (t) => {
+					var o;
+					if (t.options.memoization === false) return n(t);
+					const u = t.index, s = (o = t.cache)[a] || (o[a] = /* @__PURE__ */ new Map()), c = s.get(u);
+					if (c === false) return false;
+					if (W(c)) return t.index = c, true;
+					if (c) return t.index = c.index, c.output?.length && t.output.push(...c.output), true;
+					{
+						const Z = t.output.length;
+						if (n(t)) {
+							const D = t.index, U = t.output.length;
+							if (U > Z) {
+								const ee = t.output.slice(Z, U);
+								s.set(u, {
+									index: D,
+									output: ee
+								});
+							} else s.set(u, D);
+							return true;
+						} else return s.set(u, false), false;
+					}
+				};
+			};
+		})(), E = (r) => {
+			let e;
+			return (n) => (e || (e = v(r())), e(n));
+		}, v = Y((r) => {
+			if (d(r)) return Q(r) ? E(r) : r;
+			if (b(r) || X(r)) return i(r);
+			if (A(r)) return x(r);
+			if (K(r)) return l(Object.values(r));
+			throw new Error("Invalid rule");
+		}), P = "abcdefghijklmnopqrstuvwxyz", ir = (r) => {
+			let e = "";
+			for (; r > 0;) e = P[(r - 1) % 26] + e, r = Math.floor((r - 1) / 26);
+			return e;
+		}, O = (r) => {
+			let e = 0;
+			for (let n = 0, a = r.length; n < a; n++) e = e * 26 + P.indexOf(r[n]) + 1;
+			return e;
+		}, S = (r, e) => {
+			if (e < r) return S(e, r);
+			const n = [];
+			for (; r <= e;) n.push(r++);
+			return n;
+		}, or = (r, e, n) => S(r, e).map((a) => String(a).padStart(n, "0")), R = (r, e) => S(O(r), O(e)).map(ir), p = (r) => r, z = (r) => ur((e) => rr(e, r, { memoization: false }).join("")), ur = (r) => {
+			const e = {};
+			return (n) => e[n] ?? (e[n] = r(n));
+		}, sr = i(/^\*\*\/\*$/, ".*"), cr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]+)$/, (r, e, n) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}`), lr = i(/^\*\*\/(\*)?([ a-zA-Z0-9._-]*)\{([ a-zA-Z0-9._-]+(?:,[ a-zA-Z0-9._-]+)*)\}$/, (r, e, n, a) => `.*${e ? "" : "(?:^|/)"}${n.replaceAll(".", "\\.")}(?:${a.replaceAll(",", "|").replaceAll(".", "\\.")})`), y = i(/\\./, p), pr = i(/[$.*+?^(){}[\]\|]/, (r) => `\\${r}`), vr = i(/./, p), fr = l([i(/^(?:!!)*!(.*)$/, (r, e) => `(?!^${L(e)}$).*?`), i(/^(!!)+/, "")]), j = l([
+			i(/\/(\*\*\/)+/, "(?:/.+/|/)"),
+			i(/^(\*\*\/)+/, "(?:^|.*/)"),
+			i(/\/(\*\*)$/, "(?:/.*|$)"),
+			i(/\*\*/, ".*")
+		]), N = l([i(/\*\/(?!\*\*\/)/, "[^/]*/"), i(/\*/, "[^/]*")]), k = i("?", "[^/]"), $r = i("[", p), wr = i("]", p), Ar = i(/[!^]/, "^/"), br = i(/[a-z]-[a-z]|[0-9]-[0-9]/i, p), Er = l([
+			y,
+			i(/[$.*+?^(){}[\|]/, (r) => `\\${r}`),
+			br,
+			i(/[^\]]/, p)
+		]), B = x([
+			$r,
+			tr(Ar),
+			f(Er),
+			wr
+		]), Pr = i("{", "(?:"), Or = i("}", ")"), I = x([
+			Pr,
+			l([
+				i(/(\d+)\.\.(\d+)/, (r, e, n) => or(+e, +n, Math.min(e.length, n.length)).join("|")),
+				i(/([a-z]+)\.\.([a-z]+)/, (r, e, n) => R(e, n).join("|")),
+				i(/([A-Z]+)\.\.([A-Z]+)/, (r, e, n) => R(e.toLowerCase(), n.toLowerCase()).join("|").toUpperCase())
+			]),
+			Or
+		]), kr = i("{", "(?:"), Br = i("}", ")"), Ir = i(",", "|"), Fr = i(/[$.*+?^(){[\]\|]/, (r) => `\\${r}`), Lr = i(/[^}]/, p), F = x([
+			kr,
+			f(l([
+				j,
+				N,
+				k,
+				B,
+				I,
+				E(() => F),
+				y,
+				Fr,
+				Ir,
+				Lr
+			])),
+			Br
+		]), L = z(f(l([
+			sr,
+			cr,
+			lr,
+			fr,
+			j,
+			N,
+			k,
+			B,
+			I,
+			F,
+			y,
+			pr,
+			vr
+		]))), Tr = i(/\\./, p), qr = i(/./, p), Yr = z(f(l([
+			Tr,
+			i(/\*\*\*+/, "*"),
+			i(/([^/{[(!])\*\*/, (r, e) => `${e}*`),
+			i(/(^|.)\*\*(?=[^*/)\]}])/, (r, e) => `${e}*`),
+			qr
+		]))), $ = (r, e) => {
+			const n = Array.isArray(r) ? r : [r];
+			if (!n.length) return false;
+			const a = n.map($.compile), t = n.every((s) => /(\/(?:\*\*)?|\[\/\])$/.test(s)), o = e.replace(/[\\\/]+/g, "/").replace(/\/$/, t ? "/" : "");
+			return a.some((s) => s.test(o));
+		};
+		$.compile = (r) => new RegExp(`^${L(Yr(r))}$`, "s");
+		var re = $;
+		return J(w);
+	})();
+	return __lib__.default || __lib__;
+};
+let _match;
+const zeptomatch = (path, pattern) => {
+	if (!_match) {
+		_match = _lazyMatch();
+		_lazyMatch = null;
+	}
+	return _match(path, pattern);
+};
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const _EXTNAME_RE = /.(\.[^./]+|\.)$/;
+const _PATH_ROOT_RE = /^[/\\]|^[a-zA-Z]:[/\\]/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const toNamespacedPath = function(p) {
+	return normalizeWindowsPath(p);
+};
+const extname = function(p) {
+	if (p === "..") return "";
+	const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+	return match && match[1] || "";
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+const format = function(p) {
+	const ext = p.ext ? p.ext.startsWith(".") ? p.ext : `.${p.ext}` : "";
+	const segments = [
+		p.root,
+		p.dir,
+		p.base ?? (p.name ?? "") + ext
+	].filter(Boolean);
+	return normalizeWindowsPath(p.root ? resolve(...segments) : segments.join("/"));
+};
+const basename = function(p, extension) {
+	const segments = normalizeWindowsPath(p).split("/");
+	let lastSegment = "";
+	for (let i = segments.length - 1; i >= 0; i--) {
+		const val = segments[i];
+		if (val) {
+			lastSegment = val;
+			break;
+		}
+	}
+	return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+const parse = function(p) {
+	const root = _PATH_ROOT_RE.exec(p)?.[0]?.replace(/\\/g, "/") || "";
+	const base = basename(p);
+	const extension = extname(base);
+	return {
+		root,
+		dir: dirname(p),
+		base,
+		ext: extension,
+		name: base.slice(0, base.length - extension.length)
+	};
+};
+const matchesGlob = (path, pattern) => {
+	return zeptomatch(pattern, normalize(path));
+};
+const _path = {
+	__proto__: null,
+	basename,
+	dirname,
+	extname,
+	format,
+	isAbsolute,
+	join,
+	matchesGlob,
+	normalize,
+	normalizeString,
+	parse,
+	relative,
+	resolve,
+	sep: "/",
+	toNamespacedPath
+};
+//#endregion
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/index.mjs
+const delimiter = /* @__PURE__ */ (() => globalThis.process?.platform === "win32" ? ";" : ":")();
+const _platforms = {
+	posix: void 0,
+	win32: void 0
+};
+const mix = (del = delimiter) => {
+	return new Proxy(_path, { get(_, prop) {
+		if (prop === "delimiter") return del;
+		if (prop === "posix") return posix;
+		if (prop === "win32") return win32;
+		return _platforms[prop] || _path[prop];
+	} });
+};
+const posix = /* @__PURE__ */ mix(":");
+const win32 = /* @__PURE__ */ mix(";");
+//#endregion
+//#region src/bundlers/vite/processed-css-assets/style-files.ts
+const CSS_OUTPUT_FILE_RE = /\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i;
+function isCssOutputFile(file) {
+	return CSS_OUTPUT_FILE_RE.test(file);
+}
+function isRootStyleOutputFile(file) {
+	const normalized = require_source_candidate_scan_signature.normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+	return isCssOutputFile(normalized) && !normalized.includes("/");
+}
+function isMiniProgramStyleOutputFile(file) {
+	return /\.(?:wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i.test(file);
+}
+//#endregion
+//#region src/bundlers/vite/processed-css-assets/markers-imports.ts
+function createCssAssetPipelineContext(options, file, bundle) {
+	const context = options.createCssPipelineContext?.(file);
+	return context ? {
+		...context,
+		bundle
+	} : void 0;
+}
+function getAssetFile(bundleFile, asset) {
+	return asset.fileName || bundleFile;
+}
+function readAssetSource$1(asset) {
+	return typeof asset.source === "string" ? asset.source : asset.source.toString();
+}
+function clearAssetSource(asset) {
+	asset.source = "";
+}
+function appendCss(baseCss, css) {
+	if (baseCss.length === 0) return css;
+	if (css.length === 0) return baseCss;
+	return `${baseCss}\n${css}`;
+}
+function normalizeCssRecordIdentity(css) {
+	return css.trim();
+}
+function hasNonCommentCss(css) {
+	return css.replace(/\/\*[\s\S]*?\*\//g, "").trim().length > 0;
+}
+function dedupeViteCssResults(records) {
+	const seen = /* @__PURE__ */ new Set();
+	return records.filter((record) => {
+		const key = `${require_source_candidate_scan_signature.normalizeOutputPathKey(record.outputFile ?? "")}\0${normalizeCssRecordIdentity(record.css)}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+function removeTailwindSourceMediaWrappersRoot(root) {
+	let changed = false;
+	root.walkAtRules("media", (atRule) => {
+		if (!atRule.params.startsWith("source(")) return;
+		if (atRule.nodes && atRule.nodes.length > 0) atRule.replaceWith(...atRule.nodes);
+		else atRule.remove();
+		changed = true;
+	});
+	if (changed) root.walkAtRules((atRule) => {
+		if (atRule.nodes && atRule.nodes.length === 0) atRule.remove();
+	});
+	return changed;
+}
+function removeTailwindSourceMediaWrappersFallback(css) {
+	return css.replace(/@media\s+source\([^)]*\)\s*\{\s*\/\*!\s*weapp-tailwindcss generator-placeholder\s*\*\/?\s*\}/gi, "").replace(/@media\s+source\([^)]*\)\s*\{\s*\}/gi, "");
+}
+function removeTailwindEntryDirectivesFromCss(css) {
+	try {
+		const source = require_generator.stripGeneratorPlaceholderMarkers(css);
+		const root = _weapp_tailwindcss_postcss.postcss.parse(source);
+		const removedMediaWrappers = removeTailwindSourceMediaWrappersRoot(root);
+		const removedTailwindDirectives = (0, _weapp_tailwindcss_postcss.removeTailwindSourceDirectivesRoot)(root);
+		return removedMediaWrappers || removedTailwindDirectives ? root.toString() : source;
+	} catch {
+		return require_generator.removeTailwindSourceDirectives(removeTailwindSourceMediaWrappersFallback(css));
+	}
+}
+function removeUnsupportedMiniProgramCssImportsFallback(css, file) {
+	if (!isMiniProgramStyleOutputFile(file) || !css.includes("@import")) return css;
+	return css.split(/\r?\n/).filter((line) => {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("@import")) return true;
+		const params = trimmed.slice(7).trim().replace(/;$/, "").trim();
+		const request = (0, _weapp_tailwindcss_postcss.parseTailwindCssDirectiveRequest)(params);
+		return request === void 0 || (0, _weapp_tailwindcss_postcss.isMiniProgramLocalCssImportRequest)(request);
+	}).join("\n");
+}
+function normalizeInjectableCssForTarget(css, file) {
+	return normalizeInjectableCssForTargetWithImports(css, file).css;
+}
+function normalizeInjectableCssForTargetWithImports(css, file) {
+	if (!css.includes("@import")) return {
+		css,
+		importedStyleFiles: /* @__PURE__ */ new Set()
+	};
+	try {
+		const root = _weapp_tailwindcss_postcss.postcss.parse(css);
+		const changed = isMiniProgramStyleOutputFile(file) ? (0, _weapp_tailwindcss_postcss.removeUnsupportedMiniProgramCssImportsRoot)(root) : false;
+		const importedStyleFiles = collectImportedStyleFilesRoot(root, file);
+		return {
+			css: changed ? root.toString() : css,
+			importedStyleFiles: importedStyleFiles.size > 0 ? importedStyleFiles : collectImportedStyleFilesFallback(css, file)
+		};
+	} catch {
+		const fallbackCss = removeUnsupportedMiniProgramCssImportsFallback(css, file);
+		return {
+			css: fallbackCss,
+			importedStyleFiles: collectImportedStyleFiles(fallbackCss, file)
+		};
+	}
+}
+function stripStyleExtension(file) {
+	return file.replace(/[?#].*$/, "").replace(/\.(?:css|wxss|acss|ttss|qss|jxss|tyss|scss|sass|less|styl|stylus|pcss|postcss)$/i, "");
+}
+function isStyleImportRequest(request) {
+	return typeof request === "string" && request.length > 0 && !/^(?:https?:)?\/\//i.test(request) && /\.(?:css|wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i.test(request);
+}
+function resolveImportedStyleFile(targetFile, request) {
+	if (!isStyleImportRequest(request)) return;
+	const cleanRequest = request.replace(/[?#].*$/, "");
+	if (cleanRequest.startsWith("/")) return require_source_candidate_scan_signature.normalizeOutputPathKey(cleanRequest.slice(1));
+	const targetDir = posix.posix.dirname(require_source_candidate_scan_signature.normalizeOutputPathKey(targetFile));
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(posix.posix.join(targetDir === "." ? "" : targetDir, cleanRequest));
+}
+function collectImportedStyleFilesFromRequests(requests, targetFile) {
+	const imports = /* @__PURE__ */ new Set();
+	for (const request of requests) {
+		const importedFile = resolveImportedStyleFile(targetFile, request);
+		if (importedFile) imports.add(importedFile);
+	}
+	return imports;
+}
+function collectImportedStyleFilesRoot(root, targetFile) {
+	return collectImportedStyleFilesFromRequests((0, _weapp_tailwindcss_postcss.collectCssImportRequestsRoot)(root), targetFile);
+}
+function collectImportedStyleFilesFallback(css, targetFile) {
+	return collectImportedStyleFilesFromRequests([...css.matchAll(/@import\s+(?:url\(\s*)?(?:"([^"]+)"|'([^']+)'|([^\s;)]+))/g)].map((match) => match[1] ?? match[2] ?? match[3]).filter((request) => typeof request === "string" && request.length > 0), targetFile);
+}
+function collectImportedStyleFiles(css, targetFile) {
+	if (!css.includes("@import")) return /* @__PURE__ */ new Set();
+	try {
+		const imports = collectImportedStyleFilesRoot(_weapp_tailwindcss_postcss.postcss.parse(css), targetFile);
+		return imports.size > 0 ? imports : collectImportedStyleFilesFallback(css, targetFile);
+	} catch {}
+	return collectImportedStyleFilesFallback(css, targetFile);
+}
+function normalizeMarkerOutputFile(markerFile, resolveViteProcessedCssOutputFile) {
+	return resolveViteProcessedCssOutputFile?.(markerFile) ?? markerFile;
+}
+function isMatchingGeneratedCssMarkerFile(targetFile, markerFile, resolveViteProcessedCssOutputFile) {
+	if (!markerFile) return false;
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(stripStyleExtension(targetFile)) === require_source_candidate_scan_signature.normalizeOutputPathKey(stripStyleExtension(normalizeMarkerOutputFile(markerFile, resolveViteProcessedCssOutputFile)));
+}
+function resolveViteProcessedCssAssetSource(file, rawSource, resolveViteProcessedCssOutputFile) {
+	const blocks = require_v4_generation_core.parseBundlerGeneratedCssMarkerBlocks(rawSource).filter((block) => block.bundler === "vite");
+	if (blocks.length <= 1) return require_v4_generation_core.stripBundlerGeneratedCssMarkers(rawSource);
+	const matchedCss = blocks.filter((block) => isMatchingGeneratedCssMarkerFile(file, block.file, resolveViteProcessedCssOutputFile)).map((block) => block.css);
+	return matchedCss.length > 0 ? matchedCss.join("\n") : require_v4_generation_core.stripBundlerGeneratedCssMarkers(rawSource);
+}
+function collectMatchingGeneratedCssMarkerFiles(file, rawSource, resolveViteProcessedCssOutputFile) {
+	return require_v4_generation_core.parseBundlerGeneratedCssMarkerBlocks(rawSource).filter((block) => block.bundler === "vite").filter((block) => isMatchingGeneratedCssMarkerFile(file, block.file, resolveViteProcessedCssOutputFile)).map((block) => block.file).filter((markerFile) => typeof markerFile === "string" && markerFile.length > 0);
+}
+function collectRootStyleBundleCssSources(bundle, excludedFile) {
+	const sources = [];
+	const excludedFileKey = require_source_candidate_scan_signature.normalizeOutputPathKey(excludedFile);
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = require_source_candidate_scan_signature.normalizeOutputPathKey(getAssetFile(bundleFile, output));
+		if (file === excludedFileKey || !isRootStyleOutputFile(file)) continue;
+		const source = require_v4_generation_core.stripBundlerGeneratedCssMarkers(readAssetSource$1(output)).trim();
+		if (source.length > 0) sources.push(source);
+	}
+	return sources;
+}
+function isHtmlOutputFile(file) {
+	return /\.html(?:$|[?#])/i.test(file);
+}
+function stripQueryAndHash(file) {
+	return file.replace(/[?#].*$/, "");
+}
+function resolveHtmlLinkedStyleFile(htmlFile, request) {
+	if (!isStyleImportRequest(request)) return;
+	const cleanRequest = stripQueryAndHash(request);
+	if (cleanRequest.startsWith("/")) return require_source_candidate_scan_signature.normalizeOutputPathKey(cleanRequest.slice(1));
+	const htmlDir = posix.posix.dirname(require_source_candidate_scan_signature.normalizeOutputPathKey(stripQueryAndHash(htmlFile)));
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(posix.posix.join(htmlDir === "." ? "" : htmlDir, cleanRequest));
+}
+function collectHtmlLinkedStyleFiles(bundle) {
+	const linkedFiles = /* @__PURE__ */ new Set();
+	const linkedBasenames = /* @__PURE__ */ new Set();
+	const linkHrefRE = /<link\s[^>]*href\s*=\s*(["'])([^"']+)\1[^>]*>/gi;
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const htmlFile = getAssetFile(bundleFile, output);
+		if (!isHtmlOutputFile(htmlFile)) continue;
+		const html = readAssetSource$1(output);
+		for (const match of html.matchAll(linkHrefRE)) {
+			const href = match[2];
+			if (!href) continue;
+			const linkedFile = resolveHtmlLinkedStyleFile(htmlFile, href);
+			if (!linkedFile || !isRootStyleOutputFile(linkedFile)) continue;
+			linkedFiles.add(linkedFile);
+			linkedBasenames.add(posix.posix.basename(linkedFile));
+		}
+	}
+	return {
+		linkedBasenames,
+		linkedFiles
+	};
+}
+function isLinkedStyleFile(file, linked) {
+	const fileKey = require_source_candidate_scan_signature.normalizeOutputPathKey(stripQueryAndHash(file));
+	return linked.linkedFiles.has(fileKey) || isRootStyleOutputFile(fileKey) && linked.linkedBasenames.has(posix.posix.basename(fileKey));
+}
+function removeDuplicateUnlinkedRootCssAssetsReferencedByHtml(bundle, options = {}) {
+	const linked = collectHtmlLinkedStyleFiles(bundle);
+	if (linked.linkedFiles.size === 0 && linked.linkedBasenames.size === 0) return 0;
+	const linkedSources = /* @__PURE__ */ new Set();
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = getAssetFile(bundleFile, output);
+		if (!isCssOutputFile(file) || isMiniProgramStyleOutputFile(file) || !isLinkedStyleFile(file, linked)) continue;
+		const source = require_v4_generation_core.stripBundlerGeneratedCssMarkers(readAssetSource$1(output)).trim();
+		if (source.length > 0) linkedSources.add(source);
+	}
+	if (linkedSources.size === 0) return 0;
+	let removed = 0;
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = getAssetFile(bundleFile, output);
+		if (!isRootStyleOutputFile(file) || isMiniProgramStyleOutputFile(file) || isLinkedStyleFile(file, linked)) continue;
+		const source = require_v4_generation_core.stripBundlerGeneratedCssMarkers(readAssetSource$1(output)).trim();
+		if (!linkedSources.has(source)) continue;
+		delete bundle[bundleFile];
+		options.debug?.("remove duplicate unlinked root css asset referenced by html: %s", file);
+		removed++;
+	}
+	return removed;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/style-matching.ts
+function resolveStyleMatchingRealPath(value) {
+	const resolved = node_path.default.resolve(value);
+	let current = resolved;
+	const pendingSegments = [];
+	while (!(0, node_fs.existsSync)(current)) {
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return resolved;
+		pendingSegments.unshift(node_path.default.basename(current));
+		current = parent;
+	}
+	try {
+		const realPath = node_fs.realpathSync.native(current);
+		return pendingSegments.length > 0 ? node_path.default.join(realPath, ...pendingSegments) : realPath;
+	} catch {
+		return resolved;
+	}
+}
+function isMatchingCssSourceFile(outputFile, cssSourceFile, outputRoot) {
+	return stripStyleFileExtension(node_path.default.resolve(outputRoot, outputFile)) === stripStyleFileExtension(node_path.default.resolve(cssSourceFile));
+}
+function collectStyleFileMatchBases(file, roots) {
+	const normalizedFile = file.replace(/[?#].*$/, "");
+	const bases = /* @__PURE__ */ new Set();
+	const addBase = (candidate) => {
+		const base = slash(stripStyleFileExtension(candidate));
+		if (base.length > 0) bases.add(base);
+	};
+	addBase(normalizedFile);
+	const resolvedRoots = roots.filter((root) => typeof root === "string" && root.length > 0).map((root) => node_path.default.resolve(root));
+	if (node_path.default.isAbsolute(normalizedFile)) for (const root of resolvedRoots) {
+		const relative = node_path.default.relative(resolveStyleMatchingRealPath(root), resolveStyleMatchingRealPath(normalizedFile));
+		if (relative && !relative.startsWith("..") && !node_path.default.isAbsolute(relative)) addBase(relative);
+	}
+	else for (const root of resolvedRoots) addBase(node_path.default.resolve(root, normalizedFile));
+	return bases;
+}
+function collectParentDirectories(file) {
+	const directories = [];
+	let current = node_path.default.dirname(node_path.default.resolve(file.replace(/[?#].*$/, "")));
+	while (true) {
+		directories.push(current);
+		const parent = node_path.default.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return directories;
+}
+function hasMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	return scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) > 0;
+}
+function scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	const outputBases = collectStyleFileMatchBases(outputFile, [outputRoot]);
+	const sourceBases = collectStyleFileMatchBases(sourceFile, [sourceRoot, ...collectParentDirectories(sourceFile)]);
+	let bestScore = 0;
+	const hasDirectorySegment = (value) => slash(value).includes("/");
+	for (const outputBase of outputBases) for (const sourceBase of sourceBases) if (outputBase === sourceBase) bestScore = Math.max(bestScore, 1e5 + outputBase.length);
+	else if (hasDirectorySegment(sourceBase) && outputBase.endsWith(`/${sourceBase}`)) bestScore = Math.max(bestScore, 5e4 + sourceBase.length);
+	else if (hasDirectorySegment(outputBase) && sourceBase.endsWith(`/${outputBase}`)) bestScore = Math.max(bestScore, 1e3 + outputBase.length);
+	return bestScore;
+}
+//#endregion
+//#region src/bundlers/vite/generate-bundle/sfc-style-source.ts
+const SFC_STYLE_SOURCE_EXTENSIONS = [
+	".vue",
+	".uvue",
+	".nvue",
+	".svelte",
+	".mpx"
+];
+const SFC_STYLE_BLOCK_RE$1 = /<style\b([^>]*)>([\s\S]*?)<\/style>/gi;
+const SFC_SCOPED_STYLE_ATTR_RE = /(?:^|\s)scoped(?:\s|=|$)/i;
+const SFC_LANG_STYLE_ATTR_RE = /(?:^|\s)lang(?:=(?:"([^"]+)"|'([^']+)'|([^\s"'=<>`]+)))?/i;
+function isSfcStyleSourceFile(file) {
+	const normalizedFile = file.replace(/[?#].*$/, "");
+	return SFC_STYLE_SOURCE_EXTENSIONS.some((extension) => normalizedFile.endsWith(extension));
+}
+function extractSfcStyleBlocks(source) {
+	const styleSources = [];
+	SFC_STYLE_BLOCK_RE$1.lastIndex = 0;
+	let index = 0;
+	let match = SFC_STYLE_BLOCK_RE$1.exec(source);
+	while (match !== null) {
+		const attrs = match[1] ?? "";
+		styleSources.push({
+			attrs,
+			index,
+			scoped: SFC_SCOPED_STYLE_ATTR_RE.test(attrs),
+			source: match[2] ?? ""
+		});
+		index += 1;
+		match = SFC_STYLE_BLOCK_RE$1.exec(source);
+	}
+	return styleSources;
+}
+function extractSfcStyleSources(source) {
+	return extractSfcStyleBlocks(source).map((style) => style.source);
+}
+function hasSfcStyleSources(source) {
+	return extractSfcStyleSources(source).length > 0;
+}
+function resolveSfcStyleBlockLang(attrs) {
+	const match = SFC_LANG_STYLE_ATTR_RE.exec(attrs);
+	return match?.[1] ?? match?.[2] ?? match?.[3];
+}
+function resolveSfcStyleHandlerSourceFile(sourceFile, styleBlocks) {
+	const scopedStyleBlock = styleBlocks.find((style) => style.scoped);
+	return scopedStyleBlock ? [`${sourceFile}?vue&type=style&index=${scopedStyleBlock.index}&scoped=true`, ...resolveSfcStyleBlockLang(scopedStyleBlock.attrs) ? [`lang=${encodeURIComponent(resolveSfcStyleBlockLang(scopedStyleBlock.attrs))}`] : []].join("&") : sourceFile;
+}
+function normalizeSfcStyleSourceForCompare(source) {
+	return source.replace(/\r\n?/g, "\n").trim();
+}
+function createSfcStyleRequest(sourceFile, styleBlock) {
+	const params = new URLSearchParams();
+	params.set("vue", "");
+	params.set("type", "style");
+	params.set("index", String(styleBlock.index));
+	if (styleBlock.scoped) params.set("scoped", "true");
+	const lang = resolveSfcStyleBlockLang(styleBlock.attrs);
+	if (lang) params.set("lang", lang);
+	return `${sourceFile}?${params.toString()}`;
+}
+function resolveSfcStyleRequestFromKnownSource(sourceFile, sfcSource, styleSource, currentRequest) {
+	if (!sfcSource) return sourceFile;
+	const styleBlocks = extractSfcStyleBlocks(sfcSource);
+	if (styleBlocks.length === 0) return sourceFile;
+	const normalizedStyleSource = normalizeSfcStyleSourceForCompare(styleSource);
+	const matchedBlocks = styleBlocks.filter((styleBlock) => {
+		const normalizedBlockSource = normalizeSfcStyleSourceForCompare(styleBlock.source);
+		return normalizedBlockSource === normalizedStyleSource || normalizedBlockSource.includes(normalizedStyleSource) || normalizedStyleSource.includes(normalizedBlockSource);
+	});
+	const requestIndex = currentRequest ? Number.parseInt(new URLSearchParams(currentRequest.split("?", 2)[1] ?? "").get("index") ?? "", 10) : NaN;
+	const styleBlock = (Number.isInteger(requestIndex) ? styleBlocks.find((styleBlock) => styleBlock.index === requestIndex) : void 0) ?? (matchedBlocks.length === 1 ? matchedBlocks[0] : styleBlocks.length === 1 ? styleBlocks[0] : void 0);
+	return styleBlock ? createSfcStyleRequest(sourceFile, styleBlock) : sourceFile;
+}
+function hasTailwindGenerationSource(source, options = {}) {
+	const allowRootDirectives = options.allowRootDirectives !== false;
+	return require_generator.hasTailwindNonRootGenerationDirectives(source, { importFallback: true }) || allowRootDirectives && require_generator.hasTailwindSourceDirectives(source, { importFallback: true }) || allowRootDirectives && require_generator.hasTailwindRootDirectives(source, { importFallback: true }) || require_generator.hasTailwindApplyDirective(source);
+}
+function hasTailwindGenerationSourceForFile(file, source) {
+	if (require_generator.isTailwindV4CssEntry(file)) return hasTailwindGenerationSource(source);
+	return hasTailwindGenerationSource(source, { allowRootDirectives: false });
+}
+async function resolveSfcStyleSourceFromOutputFile(outputFile, snapshot, outputRoot, sourceRoot, cssMatcher, getSfcSource, debug) {
+	const sourceFile = resolveSfcStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, cssMatcher, debug);
+	if (!sourceFile) {
+		debug("sfc style source infer skipped: no source file for %s", outputFile);
+		return;
+	}
+	const source = getSfcSource?.(sourceFile);
+	if (source == null) {
+		debug("sfc style source infer skipped: missing known source for %s -> %s", outputFile, sourceFile);
+		return;
+	}
+	const styleBlocks = extractSfcStyleBlocks(source);
+	const rawSource = styleBlocks.map((style) => style.source).join("\n");
+	if (!rawSource || !hasTailwindGenerationSourceForFile(sourceFile, rawSource)) {
+		debug("sfc style source infer skipped: no tailwind generation source for %s -> %s", outputFile, sourceFile);
+		return;
+	}
+	debug("sfc style source inferred: %s -> %s", outputFile, sourceFile);
+	return {
+		outputFile,
+		rawSource,
+		sourceFile: resolveSfcStyleHandlerSourceFile(sourceFile, styleBlocks)
+	};
+}
+function normalizeSfcSourceFileForCompare(file) {
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+}
+function collectChunkModuleIds(output) {
+	const moduleIds = Array.isArray(output.moduleIds) ? output.moduleIds : [];
+	return [
+		output.facadeModuleId,
+		...moduleIds,
+		...Object.keys(output.modules ?? {})
+	].filter((id, index, ids) => typeof id === "string" && id.length > 0 && ids.indexOf(id) === index);
+}
+function normalizeSourceStyleModuleId(id) {
+	const file = id.replace(/[?#].*$/, "");
+	if (!CSS_SOURCE_OUTPUT_EXT_RE.test(file)) return;
+	if (!node_path.default.isAbsolute(file)) return;
+	return node_path.default.resolve(file);
+}
+function resolveSiblingJsChunkFile(outputFile, cssMatcher) {
+	const normalizedOutputFile = outputFile.replace(/[?#].*$/, "");
+	if (cssMatcher?.(normalizedOutputFile)) {
+		const extension = node_path.default.extname(normalizedOutputFile);
+		return extension ? `${normalizedOutputFile.slice(0, -extension.length)}.js` : void 0;
+	}
+	if (CSS_SOURCE_OUTPUT_EXT_RE.test(normalizedOutputFile)) return normalizedOutputFile.replace(CSS_SOURCE_OUTPUT_EXT_RE, ".js");
+}
+function normalizeSfcModuleId(id) {
+	const file = id.replace(/[?#].*$/, "");
+	if (!isSfcStyleSourceFile(file)) return;
+	if (!node_path.default.isAbsolute(file)) return;
+	return node_path.default.resolve(file);
+}
+function resolveSfcStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, cssMatcher, debug) {
+	const siblingJsFile = resolveSiblingJsChunkFile(outputFile, cssMatcher);
+	if (!siblingJsFile) {
+		debug("sfc style sibling chunk skipped: no sibling js for %s", outputFile);
+		return;
+	}
+	const normalizedSiblingJsFile = require_source_candidate_scan_signature.normalizeOutputPathKey(siblingJsFile);
+	const siblingChunk = snapshot.entries.find((entry) => entry.type === "js" && entry.output.type === "chunk" && require_source_candidate_scan_signature.normalizeOutputPathKey(entry.file) === normalizedSiblingJsFile);
+	if (!siblingChunk || siblingChunk.output.type !== "chunk") {
+		debug("sfc style sibling chunk skipped: missing chunk for %s -> %s", outputFile, siblingJsFile);
+		return;
+	}
+	const sourceFiles = collectChunkModuleIds(siblingChunk.output).map(normalizeSfcModuleId).filter((file, index, files) => Boolean(file) && files.indexOf(file) === index);
+	if (sourceFiles.length === 0) {
+		debug("sfc style sibling chunk skipped: no sfc modules for %s -> %s", outputFile, siblingJsFile);
+		return;
+	}
+	const scoredSources = sourceFiles.map((sourceFile) => ({
+		sourceFile,
+		score: scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot)
+	})).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+	debug("sfc style sibling chunk candidates: %s -> %s %O", outputFile, siblingJsFile, scoredSources);
+	const bestScore = scoredSources[0]?.score;
+	if (!bestScore) return;
+	const bestSources = scoredSources.filter((item) => item.score === bestScore);
+	if (bestSources.length !== 1) {
+		debug("sfc style sibling chunk skipped: ambiguous best sources for %s %O", outputFile, bestSources);
+		return;
+	}
+	return bestSources[0]?.sourceFile;
+}
+function resolveSourceStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, debug) {
+	const siblingJsFile = resolveSiblingJsChunkFile(outputFile, void 0);
+	if (!siblingJsFile) {
+		debug("source style sibling chunk skipped: no sibling js for %s", outputFile);
+		return;
+	}
+	const normalizedSiblingJsFile = require_source_candidate_scan_signature.normalizeOutputPathKey(siblingJsFile);
+	const siblingChunk = snapshot.entries.find((entry) => entry.type === "js" && entry.output.type === "chunk" && require_source_candidate_scan_signature.normalizeOutputPathKey(entry.file) === normalizedSiblingJsFile);
+	if (!siblingChunk || siblingChunk.output.type !== "chunk") {
+		debug("source style sibling chunk skipped: missing chunk for %s -> %s", outputFile, siblingJsFile);
+		return;
+	}
+	const sourceFiles = collectChunkModuleIds(siblingChunk.output).map(normalizeSourceStyleModuleId).filter((file, index, files) => Boolean(file) && files.indexOf(file) === index);
+	if (sourceFiles.length === 0) {
+		debug("source style sibling chunk skipped: no source style modules for %s -> %s", outputFile, siblingJsFile);
+		return;
+	}
+	if (sourceFiles.length === 1) {
+		debug("source style sibling chunk inferred from single css module: %s -> %s", outputFile, sourceFiles[0]);
+		return sourceFiles[0];
+	}
+	const scoredSources = sourceFiles.map((sourceFile) => ({
+		sourceFile,
+		score: scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot)
+	})).filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+	debug("source style sibling chunk candidates: %s -> %s %O", outputFile, siblingJsFile, scoredSources);
+	const bestScore = scoredSources[0]?.score;
+	if (!bestScore) return;
+	const bestSources = scoredSources.filter((item) => item.score === bestScore);
+	if (bestSources.length !== 1) {
+		debug("source style sibling chunk skipped: ambiguous best sources for %s %O", outputFile, bestSources);
+		return;
+	}
+	return bestSources[0]?.sourceFile;
+}
+function resolveSourceStyleSourceFromOutputFile(outputFile, snapshot, outputRoot, sourceRoot, getSourceStyleSource, getSourceStyleSources, configuredSourceEntries, debug) {
+	let sourceFile = resolveSourceStyleFileFromSiblingChunk(outputFile, snapshot, outputRoot, sourceRoot, debug);
+	let rawSource = sourceFile ? getSourceStyleSource?.(sourceFile) : void 0;
+	if (!sourceFile || !rawSource || !hasTailwindGenerationSourceForFile(sourceFile, rawSource)) {
+		const cachedSources = [...getSourceStyleSources?.() ?? []].filter(([file, source]) => CSS_SOURCE_OUTPUT_EXT_RE.test(file) && hasTailwindGenerationSourceForFile(file, source)).map(([file, source]) => ({
+			file,
+			source,
+			score: require_v4_generation_core.scoreTailwindV4CssSourceFileMatch(outputFile, file, {
+				outputRoot,
+				projectRoot: sourceRoot
+			})
+		}));
+		const configuredSources = [...configuredSourceEntries ?? []].filter(([file, source]) => CSS_SOURCE_OUTPUT_EXT_RE.test(file) && hasTailwindGenerationSourceForFile(file, source)).map(([file, source]) => ({
+			file,
+			source,
+			score: require_v4_generation_core.scoreTailwindV4CssSourceFileMatch(outputFile, file, {
+				outputRoot,
+				projectRoot: sourceRoot
+			})
+		}));
+		const scoredSources = [...cachedSources, ...configuredSources].filter((item) => item.score > 0).sort((a, b) => b.score - a.score);
+		const bestScore = scoredSources[0]?.score;
+		const bestSources = bestScore ? scoredSources.filter((item) => item.score === bestScore) : [];
+		if (bestSources.length === 1) {
+			sourceFile = bestSources[0].file;
+			rawSource = bestSources[0].source;
+			debug("source style source inferred from cache: %s -> %s", outputFile, sourceFile);
+		}
+	}
+	if (!sourceFile || !rawSource) return;
+	if (!hasTailwindGenerationSourceForFile(sourceFile, rawSource)) {
+		debug("source style source infer skipped: no tailwind generation source for %s -> %s", outputFile, sourceFile);
+		return;
+	}
+	return {
+		outputFile,
+		rawSource,
+		sourceFile
+	};
+}
+//#endregion
+//#region src/bundlers/vite/web-css-compat.ts
+/**
+* Web target 的 Tailwind 兼容转换由 generator-css 负责；Vite 外层只处理非 Web 生成目标
+* 落到 WebView 产物时的最终兼容需求，避免同一份 CSS 在 dev/build 中被重复解析转换。
+*/
+function shouldApplyViteWebCssCompat(context, strategy) {
+	if (strategy?.shouldApplyWebCssCompat?.(context) !== true) return false;
+	return !context.currentGeneratorBranch.isWeb || context.currentGeneratorOptions.webCompat !== void 0;
+}
+function resolveViteWebCssCompatOptions(context) {
+	return context.currentGeneratorBranch.isWeb ? context.currentGeneratorOptions.webCompat : context.currentGeneratorOptions.webCompat ?? true;
+}
+//#endregion
+//#region src/bundlers/vite/query.ts
+function parseVueRequest(id) {
+	const [filename = id, rawQuery] = id.split(`?`, 2);
+	const searchParams = new URLSearchParams(rawQuery);
+	const query = Object.fromEntries(searchParams);
+	if (query.vue != null) query.vue = true;
+	if (query.index != null) query.index = Number(query.index);
+	if (query.raw != null) query.raw = true;
+	if (query.url != null) query.url = true;
+	if (query.scoped != null) query.scoped = true;
+	const langTypeMatch = [...searchParams.keys()].find((key) => key.startsWith("lang."));
+	const langType = query.lang || (langTypeMatch ? langTypeMatch.slice(5) : void 0);
+	if (langType) query.lang = langType;
+	return {
+		filename,
+		query
+	};
+}
+//#endregion
+//#region src/bundlers/vite/module-identity.ts
+const WINDOWS_DRIVE_RE = /^\/?[a-z]:[\\/]/i;
+const WINDOWS_UNC_RE = /^(?:\\\\|\/\/)/;
+function unique(values) {
+	return [...new Set([...values].filter((value) => typeof value === "string" && value.length > 0))];
+}
+function decodeFileId(id) {
+	try {
+		return decodeURIComponent(id);
+	} catch {
+		return id;
+	}
+}
+function stripViteFsPrefix(id) {
+	if (!id.startsWith("/@fs/")) return id;
+	const file = id.slice(5);
+	return file.startsWith("/") || WINDOWS_DRIVE_RE.test(file) ? file : `/${file}`;
+}
+function stripFileProtocol(id) {
+	if (!id.startsWith("file://")) return id;
+	try {
+		return (0, node_url.fileURLToPath)(id);
+	} catch {
+		return id;
+	}
+}
+function isWindowsFile(file) {
+	return WINDOWS_DRIVE_RE.test(file) || WINDOWS_UNC_RE.test(file);
+}
+function normalizeWindowsFile(file) {
+	const withoutDriveSlash = /^\/[a-z]:[\\/]/i.test(file) ? file.slice(1) : file;
+	return slash(node_path.default.win32.resolve(withoutDriveSlash));
+}
+function normalizeFile(file, root) {
+	if (isWindowsFile(file) || isWindowsFile(root)) return normalizeWindowsFile(isWindowsFile(file) ? file : node_path.default.win32.resolve(root, file.replace(/^\//, "")));
+	if (node_path.default.isAbsolute(file)) {
+		if (file === root || file.startsWith(`${root}${node_path.default.sep}`) || (0, node_fs.existsSync)(file) || (0, node_fs.existsSync)(node_path.default.dirname(file))) return slash(node_path.default.resolve(file));
+		const rootRelativeFile = node_path.default.resolve(root, file.slice(1));
+		return (0, node_fs.existsSync)(rootRelativeFile) || (0, node_fs.existsSync)(node_path.default.dirname(rootRelativeFile)) ? slash(rootRelativeFile) : slash(node_path.default.resolve(file));
+	}
+	return slash(node_path.default.resolve(root, file));
+}
+function resolveRealFile(file) {
+	if (node_process.default.platform !== "win32" && isWindowsFile(file)) return file;
+	let current = file;
+	const missingSegments = [];
+	try {
+		while (true) try {
+			const resolvedParent = node_fs.realpathSync.native(current);
+			return slash(node_path.default.join(resolvedParent, ...missingSegments));
+		} catch {
+			const parent = node_path.default.dirname(current);
+			if (parent === current) return file;
+			missingSegments.unshift(node_path.default.basename(current));
+			current = parent;
+		}
+	} catch {
+		return file;
+	}
+}
+function normalizeIdentityKey(file) {
+	return isWindowsFile(file) || node_process.default.platform === "win32" ? file.toLowerCase() : file;
+}
+/**
+* 将 Vite URL、文件路径和 Windows 的等价路径收敛为同一个模块身份。
+*/
+function resolveViteModuleIdentity(id, root = node_process.default.cwd()) {
+	const cleanId = decodeFileId((0, _weapp_tailwindcss_shared.cleanUrl)(id));
+	const decodedRoot = decodeFileId((0, _weapp_tailwindcss_shared.cleanUrl)(root));
+	const normalizedRoot = isWindowsFile(decodedRoot) ? normalizeWindowsFile(decodedRoot) : slash(node_path.default.resolve(decodedRoot));
+	const unwrappedId = stripFileProtocol(stripViteFsPrefix(cleanId));
+	const file = unwrappedId.startsWith("\0") ? void 0 : normalizeFile(unwrappedId, normalizedRoot);
+	const realFile = file ? resolveRealFile(file) : void 0;
+	const key = realFile ? normalizeIdentityKey(realFile) : cleanId;
+	const pathApi = isWindowsFile(normalizedRoot) ? node_path.default.win32 : node_path.default.posix;
+	const relativeUrl = realFile && normalizeIdentityKey(realFile).startsWith(`${normalizeIdentityKey(normalizedRoot)}/`) ? `/${slash(pathApi.relative(normalizedRoot, realFile))}` : void 0;
+	return {
+		cleanId,
+		file: realFile,
+		key,
+		lookupFiles: unique([file, realFile]),
+		lookupIds: unique([
+			id,
+			cleanId,
+			unwrappedId,
+			file,
+			realFile,
+			realFile ? `/@fs/${realFile}` : void 0,
+			relativeUrl
+		])
+	};
+}
+function hasSameViteModuleIdentity(left, right, root = node_process.default.cwd()) {
+	if (!left || !right) return false;
+	return resolveViteModuleIdentity(left, root).key === resolveViteModuleIdentity(right, root).key;
+}
+//#endregion
+//#region src/bundlers/vite/hot-css-modules.ts
+async function resolveHotModulesByIds(ctx, ids, acceptModule) {
+	const modules = [];
+	const seenModules = /* @__PURE__ */ new Set();
+	const seenModuleIds = /* @__PURE__ */ new Set();
+	const seenFileIdentities = /* @__PURE__ */ new Set();
+	const root = ctx.server.config?.root ?? node_process.default.cwd();
+	const collectModule = (mod) => {
+		if (mod == null || seenModules.has(mod) || !acceptModule(mod)) return;
+		seenModules.add(mod);
+		modules.push(mod);
+	};
+	for (const id of ids) {
+		if (typeof id !== "string" || id.length === 0) continue;
+		const identity = resolveViteModuleIdentity(id, root);
+		for (const moduleId of identity.lookupIds) {
+			if (seenModuleIds.has(moduleId)) continue;
+			seenModuleIds.add(moduleId);
+			collectModule(ctx.server.moduleGraph.getModuleById?.(moduleId));
+			if (moduleId.startsWith("/")) collectModule(await ctx.server.moduleGraph.getModuleByUrl?.(moduleId));
+		}
+		if (seenFileIdentities.has(identity.key)) continue;
+		seenFileIdentities.add(identity.key);
+		for (const file of identity.lookupFiles) for (const mod of ctx.server.moduleGraph.getModulesByFile?.(file) ?? []) collectModule(mod);
+	}
+	return modules;
+}
+async function resolveHotTailwindCssModules(ctx, tailwindRootCssModuleIds, selectModules) {
+	const root = ctx.server.config?.root ?? node_process.default.cwd();
+	const outDir = ctx.server.config?.build?.outDir ? resolveViteModuleIdentity(ctx.server.config.build.outDir, root) : void 0;
+	const isHotSourceStyleModule = (id) => {
+		if (!require_v4_generation_core.isSourceStyleRequest(id)) return false;
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+		if (isRootMiniProgramStyleUrl(file) || !isAbsoluteFilePath(file) && !file.startsWith("/")) return false;
+		if (outDir) {
+			const identity = resolveViteModuleIdentity(file, root);
+			if (identity.key === outDir.key || identity.key.startsWith(`${outDir.key}/`)) return false;
+		}
+		return true;
+	};
+	const modules = await resolveHotModulesByIds(ctx, tailwindRootCssModuleIds, (mod) => {
+		const modId = mod.id ?? mod.url;
+		return isHotSourceStyleModule(modId);
+	});
+	const seenHotModules = new Set(modules);
+	for (let index = 0; index < modules.length; index++) for (const importer of modules[index]?.importers ?? []) {
+		const importerId = importer.id ?? importer.url;
+		if (!seenHotModules.has(importer) && isHotSourceStyleModule(importerId)) {
+			seenHotModules.add(importer);
+			modules.push(importer);
+		}
+	}
+	const selectedModules = selectModules?.(modules) ?? modules;
+	for (const mod of selectedModules) ctx.server.moduleGraph.invalidateModule(mod);
+	return selectedModules;
+}
+async function resolveHotSourceModulesByIds(ctx, ids) {
+	const root = ctx.server.config?.root ?? node_process.default.cwd();
+	const sourceIds = new Set(ids);
+	for (const id of ids) {
+		if (typeof id !== "string" || !/\.(?:uvue|nvue|vue|tsx?|jsx?)(?:$|[?#])/i.test(id)) continue;
+		const identity = resolveViteModuleIdentity(id, root);
+		for (const lookupId of identity.lookupIds) if (!/[?&]import(?:[=&]|$)/.test(lookupId)) sourceIds.add(`${(0, _weapp_tailwindcss_shared.cleanUrl)(lookupId)}?import`);
+	}
+	return resolveHotModulesByIds(ctx, sourceIds, (mod) => {
+		const modId = mod.id ?? mod.url;
+		return !require_v4_generation_core.isSourceStyleRequest(modId);
+	});
+}
+async function resolveHotSourceModules(ctx) {
+	const modules = [];
+	const seenModules = /* @__PURE__ */ new Set();
+	const collectModule = (mod) => {
+		if (mod == null || seenModules.has(mod)) return;
+		const modId = mod.id ?? mod.url;
+		if (require_v4_generation_core.isSourceStyleRequest(modId)) return;
+		seenModules.add(mod);
+		modules.push(mod);
+	};
+	for (const mod of ctx.modules) collectModule(mod);
+	for (const mod of await resolveHotSourceModulesByIds(ctx, [ctx.file])) collectModule(mod);
+	return modules;
+}
+function mergeHotModulesByIdentity(root, ...groups) {
+	const modules = [];
+	const seenModules = /* @__PURE__ */ new Set();
+	const seenIdentities = /* @__PURE__ */ new Set();
+	for (const mod of groups.flat()) {
+		if (seenModules.has(mod)) continue;
+		const ids = [
+			mod.id,
+			mod.url,
+			mod.file
+		].filter((id) => typeof id === "string" && id.length > 0);
+		const moduleKind = ids.some(require_v4_generation_core.isSourceStyleRequest) ? "style" : "source";
+		const keys = ids.map((id) => `${moduleKind}:${resolveViteModuleIdentity(id, root).key}`);
+		if (keys.some((key) => seenIdentities.has(key))) continue;
+		seenModules.add(mod);
+		keys.forEach((key) => seenIdentities.add(key));
+		modules.push(mod);
+	}
+	return modules;
+}
+function resolveModuleHotUrl(mod) {
+	if (typeof mod.url === "string" && mod.url.length > 0) return mod.url;
+	if (typeof mod.id === "string" && mod.id.startsWith("/")) return mod.id;
+}
+function isAbsoluteFilePath(file) {
+	return node_path.default.isAbsolute(file) || /^[A-Z]:[\\/]/i.test(file) || file.startsWith("\\\\");
+}
+function normalizeAbsoluteFilePath(file) {
+	if (/^[A-Z]:[\\/]/i.test(file) || file.startsWith("\\\\")) return slash(node_path.default.win32.resolve(file));
+	return slash(node_path.default.resolve(file));
+}
+function isRootMiniProgramStyleUrl(file) {
+	return /^\/[^/]+\.(?:wxss|acss|ttss|qss|jxss|tyss)(?:$|[?#])/i.test(file);
+}
+function resolveCssHotUrl(id, root) {
+	const suffix = /[?#]/.test(id) ? id.slice(id.search(/[?#]/)) : "";
+	const cleanId = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+	if (/^\/(?!@fs\/|[A-Z]:)/i.test(cleanId) && !cleanId.startsWith(slash(root))) {
+		if (isRootMiniProgramStyleUrl(cleanId)) return;
+		return `${cleanId}${suffix}`;
+	}
+	const file = resolveViteModuleIdentity(id, root).file ?? cleanId;
+	if (!isAbsoluteFilePath(file)) return;
+	const normalizedRoot = normalizeAbsoluteFilePath(root);
+	const normalizedFile = normalizeAbsoluteFilePath(file);
+	if (!normalizedFile.startsWith(`${normalizedRoot}/`)) return;
+	return `/${slash(node_path.default.relative(normalizedRoot, normalizedFile))}${suffix}`;
+}
+function includesHotModule(modules, target, root) {
+	const targetUrl = resolveModuleHotUrl(target);
+	const targetId = target.id;
+	return modules.some((mod) => {
+		if (mod === target) return true;
+		return targetUrl !== void 0 && resolveModuleHotUrl(mod) === targetUrl || typeof targetId === "string" && targetId.length > 0 && mod.id === targetId || [
+			target.id,
+			target.url,
+			target.file
+		].some((targetIdentity) => [
+			mod.id,
+			mod.url,
+			mod.file
+		].some((moduleIdentity) => hasSameViteModuleIdentity(targetIdentity, moduleIdentity, root)));
+	});
+}
+function includesHotId(modules, targetId, root) {
+	return modules.some((mod) => [
+		mod.id,
+		mod.url,
+		mod.file
+	].some((moduleId) => hasSameViteModuleIdentity(targetId, moduleId, root)));
+}
+function createSupplementalHotUpdate(hotUrl, timestamp) {
+	return {
+		type: "js-update",
+		timestamp,
+		path: hotUrl,
+		acceptedPath: hotUrl,
+		explicitImportRequired: false,
+		isWithinCircularImport: false
+	};
+}
+function hasSelfAcceptingNonStyleHotModule(modules) {
+	return modules.some((mod) => {
+		const modId = mod.id ?? mod.url;
+		return !require_v4_generation_core.isSourceStyleRequest(modId) && mod.isSelfAccepting === true;
+	});
+}
+function sendSupplementalCssHotUpdates(ctx, cssModules, fallbackCssIds = [], fallbackSourceIds = [], handledModules = ctx.modules) {
+	const seenUrls = /* @__PURE__ */ new Set();
+	const root = ctx.server.config?.root ?? node_process.default.cwd();
+	const updates = [];
+	for (const id of fallbackSourceIds) {
+		if (includesHotId(handledModules, id, root)) continue;
+		const hotUrl = resolveCssHotUrl(id, root);
+		if (!hotUrl || seenUrls.has(hotUrl)) continue;
+		seenUrls.add(hotUrl);
+		updates.push(createSupplementalHotUpdate(hotUrl, ctx.timestamp));
+	}
+	for (const id of fallbackCssIds) {
+		if (!require_v4_generation_core.isSourceStyleRequest(id) || includesHotId(handledModules, id, root)) continue;
+		const hotUrl = resolveCssHotUrl(id, root);
+		if (!hotUrl || seenUrls.has(hotUrl)) continue;
+		seenUrls.add(hotUrl);
+		updates.push(createSupplementalHotUpdate(hotUrl, ctx.timestamp));
+	}
+	for (const mod of cssModules) {
+		if (includesHotModule(handledModules, mod, root)) continue;
+		const moduleHotUrl = resolveModuleHotUrl(mod);
+		const hotUrl = moduleHotUrl ? resolveCssHotUrl(moduleHotUrl, root) : void 0;
+		if (!hotUrl || seenUrls.has(hotUrl)) continue;
+		seenUrls.add(hotUrl);
+		updates.push(createSupplementalHotUpdate(hotUrl, ctx.timestamp));
+	}
+	if (updates.length === 0) return;
+	queueMicrotask(() => {
+		ctx.server.ws?.send?.({
+			type: "update",
+			updates
+		});
+	});
+}
+function sendFullReloadForUnresolvedHotUpdate(ctx) {
+	ctx.server.ws?.send?.({
+		type: "full-reload",
+		path: "*",
+		triggeredBy: ctx.file
+	});
+}
+//#endregion
+//#region src/bundlers/vite/shared/generic-web-production-fast-path.ts
+/**
+* Generic Web 非 watch 生产构建由 Tailwind Scanner 直接提供候选，不需要重复维护小程序候选状态。
+*/
+function shouldSkipGenericWebProductionSourceCandidates(options) {
+	return options.frameworkName === "generic" && options.command === "build" && options.watch == null && options.isWebGeneratorTarget && options.requiresSourceCandidateState !== true;
+}
+/**
+* 在 Vite 解析插件列表时排除无需维护的候选层，避免其 hooks 进入模块图。
+*/
+function createGenericWebProductionSourceCandidatesApply(options) {
+	return (config, env) => !shouldSkipGenericWebProductionSourceCandidates({
+		command: env.command,
+		frameworkName: options.frameworkName,
+		isWebGeneratorTarget: options.getIsWebGeneratorTarget(),
+		requiresSourceCandidateState: options.requiresSourceCandidateState,
+		watch: config.build?.watch
+	});
+}
+/**
+* Generic Web 生产构建的 CSS 已在 Vite transform 阶段生成时，不需要再建立面向小程序的完整产物快照。
+*/
+function shouldUseGenericWebProductionFastPath(options) {
+	return shouldSkipGenericWebProductionSourceCandidates(options) && options.hasProcessedCss;
+}
+/**
+* Finalizer fast path 只处理无小程序结构语义的 Generic Web 生产产物。
+*/
+function shouldUseGenericWebFinalizerFastPath(options) {
+	return shouldUseGenericWebProductionFastPath(options) && !options.hasFrameworkRootImportShells && !options.isHarmonyAppStyleTarget && !options.isNativeAppStyleTarget;
+}
+/**
+* 将 Generic Web fast path 的判定和跳过生命周期集中起来，供 generateBundle hook 直接消费。
+*/
+function createGenericWebProductionBundleHooks(options) {
+	return {
+		onSkipProcessBundle: () => {
+			options.onStart();
+			options.onEnd();
+		},
+		shouldProcessBundle: () => {
+			const config = options.getResolvedConfig();
+			return !shouldUseGenericWebProductionFastPath({
+				command: config?.command,
+				frameworkName: options.frameworkName,
+				hasProcessedCss: options.getHasProcessedCss(),
+				isWebGeneratorTarget: options.getIsWebGeneratorTarget(),
+				watch: config?.build?.watch
+			});
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/vite/css-finalizer/options.ts
+function inferPlatformFromViteOutDir(outDir) {
+	const segment = outDir ? node_path.default.basename(node_path.default.normalize(outDir)) : void 0;
+	if (!segment) return;
+	const normalized = segment.trim().toLowerCase();
+	if (normalized === "h5" || normalized === "web" || normalized === "app" || normalized === "app-plus" || normalized.startsWith("app-") || normalized.startsWith("mp-") || normalized.startsWith("quickapp-webview")) return normalized;
+}
+function isAddWatchFileInvalidRollupPhaseError(error) {
+	const candidate = error;
+	return candidate?.code === "INVALID_ROLLUP_PHASE" || candidate?.pluginCode === "INVALID_ROLLUP_PHASE" || candidate?.message?.includes("Cannot call \"addWatchFile\" after the build has finished.") === true;
+}
+function registerGeneratorDependencies(ctx, dependencies) {
+	if (typeof ctx.addWatchFile !== "function") return;
+	for (const dependency of dependencies ?? []) try {
+		ctx.addWatchFile(dependency);
+	} catch (error) {
+		if (isAddWatchFileInvalidRollupPhaseError(error)) {
+			_weapp_tailwindcss_logger.logger.debug("跳过生成模式依赖监听注册，当前 Rollup 阶段不允许 addWatchFile: %s", dependency);
+			continue;
+		}
+		throw error;
+	}
+}
+function createCssHandlerOptions(opts, majorVersion, file, outputRoot, extraOptions = {}) {
+	const from = node_path.default.isAbsolute(file) ? file : outputRoot ? node_path.default.resolve(outputRoot, file) : file;
+	return {
+		...extraOptions,
+		cssPreflight: opts.cssPreflight,
+		isMainChunk: opts.mainCssChunkMatcher(file, opts.appType),
+		postcssOptions: { options: { from } },
+		...require_compiler.normalizeStyleHandlerMajorVersion(majorVersion) === void 0 ? {} : { majorVersion: 4 }
+	};
+}
+function shouldGenerateCssByGenerator(opts, majorVersion, file, rawSource, processed) {
+	const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+		appType: opts.appType,
+		platform: opts.cssOptions?.platform ?? opts.platform,
+		tailwindcssMajorVersion: majorVersion,
+		uniAppX: opts.uniAppX
+	});
+	if (!generatorOptions.enabled) return false;
+	if (require_generator.hasLocalCssImport(rawSource)) return false;
+	if (require_generator.hasTailwindGeneratedCssMarkers(rawSource)) return true;
+	if (require_generator.hasTailwindRootDirectives(rawSource, { importFallback: generatorOptions.importFallback })) return true;
+	return processed && require_generator.hasTailwindApplyDirective(rawSource) && shouldFinalizeProcessedCssAsset(opts, file);
+}
+function shouldFinalizeProcessedCssAsset(opts, file) {
+	return opts.mainCssChunkMatcher(file, opts.appType);
+}
+function collectViteProcessedCssSources(getViteProcessedCssAssetResults) {
+	return [...getViteProcessedCssAssetResults?.() ?? []].map(([, record]) => typeof record === "string" ? record : record.css);
+}
+function finalizeWebCss(css, context, cssPipelineStrategy) {
+	const shouldApplyWebCssCompat = shouldApplyViteWebCssCompat(context, cssPipelineStrategy);
+	const defaultWebCssCompat = (value) => (0, _weapp_tailwindcss_postcss.transformWebCssCompat)(value, resolveViteWebCssCompatOptions(context));
+	return cssPipelineStrategy?.transformGeneratedCss?.(css, {
+		...context,
+		defaultWebCssCompat,
+		removeScopedPreflight: (value) => value,
+		shouldApplyWebCssCompat
+	}) ?? (shouldApplyWebCssCompat ? defaultWebCssCompat(css) : css);
+}
+//#endregion
+//#region src/bundlers/vite/css-finalizer/generic-web-fast-path.ts
+function readAssetSource(asset) {
+	return typeof asset.source === "string" ? asset.source : asset.source.toString();
+}
+function collectCssAssets(bundle, context) {
+	const assets = /* @__PURE__ */ new Map();
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = output.fileName || bundleFile;
+		if (!context.opts.cssMatcher(file) || context.opts.htmlMatcher(file)) continue;
+		assets.set(require_source_candidate_scan_signature.normalizeOutputPathKey(file), {
+			asset: output,
+			file,
+			original: readAssetSource(output)
+		});
+	}
+	return assets;
+}
+function resolveProcessedCssOutputFile(file, options, bundleFiles) {
+	return resolveViteCssPipelineOutputFile(file, options.context.opts, options.rootDir, true, false, options.sourceRoot, ".css", bundleFiles);
+}
+function resolveProcessedCssAssets(cssAssets, records, options, bundleFiles) {
+	const assetBySourceFile = /* @__PURE__ */ new Map();
+	for (const output of cssAssets.values()) {
+		const identity = options.context.resolveCssAssetIdentity?.(output.asset, output.file);
+		if (identity?.kind === "bundler-generated" && identity.sourceFile) assetBySourceFile.set(require_source_candidate_scan_signature.normalizeOutputPathKey(identity.sourceFile), output);
+		for (const sourceFile of collectMatchingGeneratedCssMarkerFiles(output.file, output.original, (file) => resolveProcessedCssOutputFile(file, options, bundleFiles))) assetBySourceFile.set(require_source_candidate_scan_signature.normalizeOutputPathKey(sourceFile), output);
+	}
+	const processedAssets = /* @__PURE__ */ new Map();
+	const htmlOwnedAssets = [...cssAssets.values()].filter((output) => [output.asset.originalFileName, ...output.asset.originalFileNames ?? []].some((file) => typeof file === "string" && /\.html(?:$|[?#])/i.test(file)));
+	for (const [file, record] of records) {
+		const recordCss = typeof record === "string" ? record : record.css;
+		const outputFile = typeof record === "string" ? resolveProcessedCssOutputFile(file, options, bundleFiles) : record.outputFile ?? resolveProcessedCssOutputFile(file, options, bundleFiles);
+		let output = assetBySourceFile.get(require_source_candidate_scan_signature.normalizeOutputPathKey(file)) ?? (outputFile ? cssAssets.get(require_source_candidate_scan_signature.normalizeOutputPathKey(outputFile)) : void 0);
+		let useAssetSource = output !== void 0;
+		if (!output) {
+			const matchingAssets = [...cssAssets.values()].filter((candidate) => options.context.isCssAssetProcessed(candidate.asset, candidate.file) && resolveViteProcessedCssAssetSource(candidate.file, candidate.original, (sourceFile) => resolveProcessedCssOutputFile(sourceFile, options, bundleFiles)) === recordCss);
+			if (matchingAssets.length === 1) {
+				output = matchingAssets[0];
+				useAssetSource = true;
+			}
+		}
+		if (!output && records.length === 1 && htmlOwnedAssets.length === 1) {
+			output = htmlOwnedAssets[0];
+			useAssetSource = require_generator.hasTailwindGeneratedCss(output.original) || require_generator.hasTailwindGeneratedCssMarkers(output.original);
+		}
+		if (!output) return;
+		const existing = processedAssets.get(output);
+		if (existing !== void 0 && existing.css !== recordCss) return;
+		processedAssets.set(output, {
+			css: recordCss,
+			useAssetSource
+		});
+	}
+	return processedAssets;
+}
+/**
+* Generic Web 的 transform 结果能唯一映射到最终 CSS asset 时，只做一次 marker 清理和 Web 兼容收尾。
+*/
+function tryFinalizeGenericWebCss(options) {
+	const { bundle, context } = options;
+	const resolvedConfig = context.getResolvedConfig();
+	const collectStartedAt = performance.now();
+	const processedCssResults = [...context.getViteProcessedCssAssetResults?.() ?? []];
+	if (!shouldUseGenericWebFinalizerFastPath({
+		command: resolvedConfig?.command,
+		frameworkName: context.frameworkName ?? "",
+		hasFrameworkRootImportShells: (context.frameworkRootImportShellTargetByFile?.size ?? 0) > 0,
+		hasProcessedCss: processedCssResults.length > 0,
+		isHarmonyAppStyleTarget: options.isHarmonyAppStyleTarget,
+		isNativeAppStyleTarget: options.isNativeAppStyleTarget,
+		isWebGeneratorTarget: options.isWebGeneratorTarget,
+		watch: resolvedConfig?.build?.watch
+	})) return false;
+	const enumerateStartedAt = performance.now();
+	const cssAssets = collectCssAssets(bundle, context);
+	const bundleFiles = [...cssAssets.values()].map((item) => item.file);
+	options.recordTiming("assets.enumerate", enumerateStartedAt);
+	const processedAssets = resolveProcessedCssAssets(cssAssets, processedCssResults, options, bundleFiles);
+	options.recordTiming("processedCss.collect", collectStartedAt);
+	if (!processedAssets) return false;
+	const writeStartedAt = performance.now();
+	for (const [{ asset, file, original }, processed] of processedAssets) {
+		const finalizeStartedAt = performance.now();
+		const finalCssSource = processed.useAssetSource ? original : processed.css;
+		const generated = finalizeWebCss(require_v4_generation_core.stripBundlerGeneratedCssMarkers(finalCssSource), {
+			...options.createCssPipelineContext(file),
+			file
+		}, context.cssPipelineStrategy);
+		options.recordTiming("finalizeWebCss", finalizeStartedAt);
+		asset.source = generated;
+		context.markCssAssetProcessed(asset, file);
+		context.recordCssAssetResult?.(file, generated);
+		if (generated !== original) context.opts.onUpdate(file, original, generated);
+	}
+	options.recordTiming("processedCss.inject", performance.now());
+	options.recordTiming("assets.markerCleanupWrite", writeStartedAt);
+	return true;
+}
+//#endregion
+//#region src/bundlers/vite/css-finalizer/web-plugin.ts
+/**
+* Generic Web 专用 CSS finalizer。
+*
+* 该插件只处理已经在 CSS transform 阶段记录的 CSS asset，不扫描或改写
+* HTML、JavaScript、模板和小程序分包产物。
+*/
+function createViteWebCssFinalizerOutputPlugin(context) {
+	return {
+		name: "weapp-tailwindcss:adaptor:web-css-finalizer",
+		enforce: "post",
+		async closeBundle() {
+			if (context.getResolvedConfig()?.build?.watch != null) return;
+			await require_compiler.disposeCompilerOwner(context.runtimeState);
+		},
+		async closeWatcher() {
+			await require_compiler.disposeCompilerOwner(context.runtimeState);
+		},
+		generateBundle: {
+			order: "post",
+			async handler(_options, bundle) {
+				const resolvedConfig = context.getResolvedConfig();
+				if (resolvedConfig?.command !== "build") return;
+				const rootDir = resolvedConfig.root ? node_path.default.resolve(resolvedConfig.root) : node_process.default.cwd();
+				const recordTiming = (phase, startedAt) => {
+					context.hmrTimingRecorder?.record(`webCssFinalizer.${phase}`, performance.now() - startedAt);
+				};
+				const startedAt = performance.now();
+				if (!tryFinalizeGenericWebCss({
+					bundle,
+					context,
+					createCssPipelineContext: (file) => ({
+						bundle,
+						currentGeneratorBranch: {
+							isWeb: true,
+							isNativeApp: false,
+							isMiniProgram: false
+						},
+						currentGeneratorOptions: {
+							target: "web",
+							enabled: true
+						},
+						file,
+						opts: context.opts,
+						resolvedConfig,
+						resolveStylePlatform: () => "web"
+					}),
+					isHarmonyAppStyleTarget: false,
+					isNativeAppStyleTarget: false,
+					isWebGeneratorTarget: true,
+					recordTiming,
+					rootDir,
+					sourceRoot: void 0
+				})) context.debug("Generic Web CSS finalizer skipped: no unique processed CSS asset");
+				require_hmr_timing.finalizeCompilerShadowRun(context.runtimeState);
+				context.hmrTimingRecorder?.record("webCssFinalizer.total", performance.now() - startedAt);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/vite/map-cache.ts
+function touchMapEntry(map, key, value) {
+	map.delete(key);
+	map.set(key, value);
+}
+function pruneMapToMaxSize(map, maxSize, onDelete) {
+	while (map.size > maxSize) {
+		const key = map.keys().next().value;
+		if (key === void 0) break;
+		map.delete(key);
+		onDelete?.(key);
+	}
+}
+//#endregion
+//#region src/bundlers/vite/css-memory.ts
+const VITE_REMEMBERED_CSS_CACHE_MAX = 96;
+const VITE_KNOWN_SFC_SOURCE_CACHE_MAX = 128;
+const SFC_STYLE_BLOCK_RE = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+const SFC_COMPONENT_FILE_RE = /\.(?:vue|uvue|nvue|svelte|mpx)$/i;
+function toMb$1(bytes) {
+	return Math.round(bytes / 1024 / 1024);
+}
+function summarizeStringMapCache(map) {
+	let bytes = 0;
+	for (const value of map.values()) bytes += value.length;
+	return {
+		bytes,
+		mb: toMb$1(bytes),
+		size: map.size
+	};
+}
+function summarizeRememberedCssSources(map) {
+	let bytes = 0;
+	for (const value of map.values()) bytes += value.rawSource.length;
+	return {
+		bytes,
+		mb: toMb$1(bytes),
+		size: map.size
+	};
+}
+function stripSourceHash(sourceFile) {
+	const hashIndex = sourceFile.indexOf("#");
+	return hashIndex === -1 ? sourceFile : sourceFile.slice(0, hashIndex);
+}
+function normalizeCssSourceIdentity(sourceFile) {
+	const cleanSourceFile = stripSourceHash(sourceFile);
+	const { filename, query } = parseVueRequest(cleanSourceFile);
+	const normalizedFile = require_source_candidate_scan_signature.normalizeOutputPathKey(filename);
+	if (query.type === "style") return `${normalizedFile}?type=style&index=${query.index ?? 0}`;
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(require_v4_generation_core.stripRequestQuery(cleanSourceFile));
+}
+function hasSfcStyleBlocks(source) {
+	SFC_STYLE_BLOCK_RE.lastIndex = 0;
+	return SFC_STYLE_BLOCK_RE.test(source);
+}
+function extractSfcStyleBlock(source, index) {
+	const targetIndex = index ?? 0;
+	SFC_STYLE_BLOCK_RE.lastIndex = 0;
+	let currentIndex = 0;
+	let match = SFC_STYLE_BLOCK_RE.exec(source);
+	while (match !== null) {
+		if (currentIndex === targetIndex) return match[1] ?? "";
+		currentIndex++;
+		match = SFC_STYLE_BLOCK_RE.exec(source);
+	}
+}
+function extractSfcStyleSource(source, index) {
+	if (index !== void 0) return extractSfcStyleBlock(source, index);
+	const styleSources = [];
+	SFC_STYLE_BLOCK_RE.lastIndex = 0;
+	let match = SFC_STYLE_BLOCK_RE.exec(source);
+	while (match !== null) {
+		styleSources.push(match[1] ?? "");
+		match = SFC_STYLE_BLOCK_RE.exec(source);
+	}
+	return styleSources.length > 0 ? styleSources.join("\n") : void 0;
+}
+function normalizeKnownSfcSourceKey(file) {
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(node_path.default.resolve((0, _weapp_tailwindcss_shared.cleanUrl)(file)));
+}
+function shouldCollectTransformedSourceCandidates(id) {
+	if (isWeappViteSidecarRequest(id)) return false;
+	if (id.search(/[?#]/) < 0) return true;
+	const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+	return !SFC_COMPONENT_FILE_RE.test(file);
+}
+function createViteCssMemory(options) {
+	const rememberedCssSources = /* @__PURE__ */ new Map();
+	const rememberedCssSignatureByFile = /* @__PURE__ */ new Map();
+	const knownCssSources = /* @__PURE__ */ new Map();
+	const knownSfcSources = /* @__PURE__ */ new Map();
+	const rememberKnownSfcSource = (id, code) => {
+		if (id.search(/[?#]/) >= 0) return;
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+		if (!SFC_COMPONENT_FILE_RE.test(file)) return;
+		if (!hasSfcStyleBlocks(code)) return;
+		touchMapEntry(knownSfcSources, normalizeKnownSfcSourceKey(file), code);
+		pruneMapToMaxSize(knownSfcSources, VITE_KNOWN_SFC_SOURCE_CACHE_MAX);
+	};
+	const getKnownSfcSource = (file) => {
+		const scanSource = options.getSourceCandidateSource(file);
+		if (scanSource && hasSfcStyleBlocks(scanSource)) return scanSource;
+		const key = normalizeKnownSfcSourceKey(file);
+		const source = knownSfcSources.get(key);
+		if (source != null) touchMapEntry(knownSfcSources, key, source);
+		return source;
+	};
+	const getKnownCssSource = (file) => {
+		const source = knownCssSources.get(normalizeCssSourceIdentity(file));
+		if (source != null) touchMapEntry(knownCssSources, normalizeCssSourceIdentity(file), source);
+		return source;
+	};
+	const rememberCssSource = (entry, cssRuntimeSignature) => {
+		getActiveViteSourceOutputRelationOwner()?.recordOwnedOutput(entry.sourceFile, entry.outputFile);
+		const outputKey = require_source_candidate_scan_signature.normalizeOutputPathKey(entry.outputFile);
+		const normalizedSourceFile = normalizeCssSourceIdentity(entry.sourceFile);
+		const previousOutputEntry = rememberedCssSources.get(outputKey);
+		const key = previousOutputEntry != null && normalizeCssSourceIdentity(previousOutputEntry.sourceFile) !== normalizedSourceFile ? `${outputKey}\0${normalizedSourceFile}` : outputKey;
+		const previous = rememberedCssSources.get(key);
+		touchMapEntry(rememberedCssSources, key, entry);
+		const relatedRememberedEntries = [...rememberedCssSources].filter(([rememberedKey, remembered]) => rememberedKey !== key && normalizeCssSourceIdentity(remembered.sourceFile) === normalizedSourceFile);
+		for (const [rememberedKey, remembered] of relatedRememberedEntries) {
+			touchMapEntry(rememberedCssSources, rememberedKey, {
+				...remembered,
+				outputFile: entry.outputFile,
+				rawSource: entry.rawSource,
+				sourceFile: entry.sourceFile
+			});
+			rememberedCssSignatureByFile.delete(rememberedKey);
+		}
+		if (cssRuntimeSignature) rememberedCssSignatureByFile.set(key, cssRuntimeSignature);
+		else if (previous?.rawSource !== entry.rawSource || previous?.sourceFile !== entry.sourceFile) rememberedCssSignatureByFile.delete(key);
+		pruneMapToMaxSize(rememberedCssSources, VITE_REMEMBERED_CSS_CACHE_MAX, (rememberedKey) => {
+			rememberedCssSignatureByFile.delete(String(rememberedKey));
+		});
+	};
+	const refreshRememberedCssSourceEntry = (rememberedKey, remembered, sourceFile, rawSource) => {
+		if (remembered.rawSource === rawSource && remembered.sourceFile === sourceFile) return remembered;
+		const nextRemembered = {
+			...remembered,
+			rawSource,
+			sourceFile
+		};
+		touchMapEntry(rememberedCssSources, rememberedKey, nextRemembered);
+		rememberedCssSignatureByFile.delete(rememberedKey);
+		return nextRemembered;
+	};
+	const refreshRememberedCssSourceBySourceFile = (sourceFile, rawSource) => {
+		touchMapEntry(knownCssSources, normalizeCssSourceIdentity(sourceFile), rawSource);
+		const normalizedSourceFile = normalizeCssSourceIdentity(sourceFile);
+		const relatedRememberedEntries = [...rememberedCssSources].filter(([, remembered]) => normalizeCssSourceIdentity(remembered.sourceFile) === normalizedSourceFile);
+		for (const [rememberedKey, remembered] of relatedRememberedEntries) refreshRememberedCssSourceEntry(rememberedKey, remembered, sourceFile, rawSource);
+	};
+	const resolveCachedStyleSource = (sourceFile) => {
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(require_v4_generation_core.stripRequestQuery(sourceFile));
+		if (SFC_COMPONENT_FILE_RE.test(file)) return getKnownSfcSource(file);
+		if (require_v4_generation_core.isSourceStyleRequest(file)) return options.getSourceCandidateSource(file);
+	};
+	const resolveCurrentStyleSource = (sourceFile) => {
+		const cached = resolveCachedStyleSource(sourceFile);
+		if (cached != null) return cached;
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(require_v4_generation_core.stripRequestQuery(sourceFile));
+		const knownSource = knownCssSources.get(normalizeCssSourceIdentity(sourceFile));
+		if (knownSource != null) return knownSource;
+		const candidateSource = options.getSourceCandidateSource(file);
+		if (candidateSource != null) return candidateSource;
+	};
+	const refreshRememberedCssSourceByCurrentFile = async (sourceFile) => {
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(sourceFile);
+		const normalizedSourceFile = require_source_candidate_scan_signature.normalizeOutputPathKey(file);
+		const matchedRememberedSources = [...rememberedCssSources.values()].filter((remembered) => require_source_candidate_scan_signature.normalizeOutputPathKey(require_v4_generation_core.stripRequestQuery((0, _weapp_tailwindcss_shared.cleanUrl)(remembered.sourceFile))) === normalizedSourceFile);
+		if (matchedRememberedSources.length === 0) return;
+		const source = await resolveCurrentStyleSource(file);
+		if (source == null) {
+			options.debug("refresh remembered css source skipped: missing cached source for %s", file);
+			return;
+		}
+		if (SFC_COMPONENT_FILE_RE.test(file)) {
+			for (const remembered of matchedRememberedSources) {
+				const { query } = parseVueRequest(remembered.sourceFile);
+				const styleSource = extractSfcStyleSource(source, query.type === "style" ? query.index : void 0);
+				if (styleSource !== void 0) refreshRememberedCssSourceBySourceFile(remembered.sourceFile, styleSource);
+			}
+			return;
+		}
+		if (require_v4_generation_core.isSourceStyleRequest(file)) refreshRememberedCssSourceBySourceFile(file, source);
+	};
+	const prune = (pruneOptions) => {
+		const activeFiles = new Set([...pruneOptions.activeFiles].map(require_source_candidate_scan_signature.normalizeOutputPathKey));
+		for (const [key, remembered] of rememberedCssSources) {
+			const outputKey = require_source_candidate_scan_signature.normalizeOutputPathKey(remembered.outputFile);
+			const sourceKey = require_source_candidate_scan_signature.normalizeOutputPathKey(remembered.sourceFile);
+			if (!activeFiles.has(key) && !activeFiles.has(outputKey) && !activeFiles.has(sourceKey)) {
+				rememberedCssSources.delete(key);
+				rememberedCssSignatureByFile.delete(key);
+			}
+		}
+		if (pruneOptions.activeKnownSfcFiles) {
+			const activeKnownSfcFiles = new Set([...pruneOptions.activeKnownSfcFiles].map((file) => normalizeKnownSfcSourceKey(file)).filter((file) => SFC_COMPONENT_FILE_RE.test(file)));
+			for (const key of knownSfcSources.keys()) if (!activeKnownSfcFiles.has(key)) knownSfcSources.delete(key);
+		}
+		pruneMapToMaxSize(rememberedCssSources, VITE_REMEMBERED_CSS_CACHE_MAX, (rememberedKey) => {
+			rememberedCssSignatureByFile.delete(String(rememberedKey));
+		});
+		pruneMapToMaxSize(knownCssSources, VITE_REMEMBERED_CSS_CACHE_MAX);
+		pruneMapToMaxSize(knownSfcSources, VITE_KNOWN_SFC_SOURCE_CACHE_MAX);
+	};
+	return {
+		getKnownSfcSource,
+		getKnownCssSource,
+		getRememberedCssSignature: (file) => rememberedCssSignatureByFile.get(require_source_candidate_scan_signature.normalizeOutputPathKey(file)),
+		getRememberedCssSourceEntry: (file) => rememberedCssSources.get(require_source_candidate_scan_signature.normalizeOutputPathKey(file)),
+		getRememberedCssSources: () => rememberedCssSources,
+		getStats: () => ({
+			rememberedCssSources: rememberedCssSources.size,
+			rememberedCssSourcesRaw: summarizeRememberedCssSources(rememberedCssSources),
+			rememberedCssSignatureByFile: rememberedCssSignatureByFile.size,
+			knownCssSources: knownCssSources.size,
+			knownCssSourcesRaw: summarizeStringMapCache(knownCssSources),
+			knownSfcSources: knownSfcSources.size,
+			knownSfcSourcesRaw: summarizeStringMapCache(knownSfcSources)
+		}),
+		rememberCssSource,
+		rememberKnownSfcSource,
+		refreshRememberedCssSourceByCurrentFile,
+		refreshRememberedCssSourceBySourceFile,
+		setRememberedCssSignature: (file, cssRuntimeSignature) => {
+			rememberedCssSignatureByFile.set(require_source_candidate_scan_signature.normalizeOutputPathKey(file), cssRuntimeSignature);
+		},
+		prune
+	};
+}
+//#endregion
+//#region src/bundlers/vite/plugin-cache.ts
+function isMissingInternalCssSource(file, packageDir) {
+	return !(0, node_fs.existsSync)(file) && node_path.default.resolve(file).startsWith(`${packageDir}${node_path.default.sep}`);
+}
+function normalizeVitePersistentCacheKey(file) {
+	return require_source_candidate_scan_signature.normalizeOutputPathKey(file);
+}
+function toMb(bytes) {
+	return Math.round(bytes / 1024 / 1024);
+}
+function summarizeStringCache(map) {
+	let bytes = 0;
+	for (const value of map.values()) bytes += value.length;
+	return {
+		bytes,
+		mb: toMb(bytes),
+		size: map.size
+	};
+}
+function summarizeViteProcessedCssResults(map) {
+	let bytes = 0;
+	for (const record of map.values()) bytes += record.css.length;
+	return {
+		bytes,
+		mb: toMb(bytes),
+		size: map.size
+	};
+}
+//#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 require_v4_generation_core.isSourceStyleRequest(importer) || isCSSRequest(normalized) || normalized.endsWith("/*");
+}
+function stripTailwindConfigDirectives(code) {
+	return code.replace(/^\s*@config\s+(?:"[^"]+"|'[^']+')[^;\n]*;\s*$/gm, "");
+}
+function createRewriteCssImportsPlugins(options) {
+	if (!options.shouldRewrite && !options.shouldOwnTailwindGeneration) return [];
+	const { appType, getAppType, rootImport, shouldOwnTailwindGeneration, weappTailwindcssDirPosix } = options;
+	const resolveAppType = () => getAppType?.() ?? appType;
+	return [{
+		name: `${require_compiler.vitePluginName}:rewrite-css-imports`,
+		enforce: "pre",
+		resolveId(id, importer) {
+			if (!options.shouldRewrite) return null;
+			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;
+		},
+		async transform(code, id) {
+			if (!isCSSRequest(id)) return null;
+			const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+			const normalizedCode = !isSfcStyleSourceFile(file) && (require_generator.hasTailwindRootDirectives(code) || code.includes("@config")) ? require_generator.normalizeTailwindConfigDirectives(code, node_path.default.dirname(file)) : code;
+			await options.onCssSourceTransform?.(id, normalizedCode);
+			const hasTailwindRoot = require_generator.hasTailwindRootDirectives(normalizedCode, { importFallback: true });
+			if (hasTailwindRoot) await options.onTailwindRootCss?.(id, normalizedCode);
+			const shouldGenerateInPreTransform = !options.shouldDeferGeneration?.(id, normalizedCode) && (hasTailwindRoot || options.shouldGenerateCss?.(id, normalizedCode));
+			if (options.shouldOwnTailwindGeneration && shouldGenerateInPreTransform) {
+				const generatedCss = await options.generateTailwindCss?.(id, normalizedCode, {
+					...this.addWatchFile ? { addWatchFile: this.addWatchFile.bind(this) } : {},
+					...this.emitFile ? { emitFile: this.emitFile.bind(this) } : {},
+					cssStage: "raw"
+				});
+				if (generatedCss !== void 0) return {
+					code: generatedCss,
+					map: null
+				};
+			}
+			if (!options.shouldRewrite) {
+				if (normalizedCode !== code) return {
+					code: normalizedCode,
+					map: null
+				};
+				return null;
+			}
+			const rewritten = require_css_imports.rewriteTailwindcssImportsInCode(normalizedCode, weappTailwindcssDirPosix, {
+				join: joinPosixPath,
+				appType: resolveAppType(),
+				rootImport
+			});
+			const nextCode = shouldOwnTailwindGeneration ? stripTailwindConfigDirectives(rewritten ?? normalizedCode) : rewritten;
+			if (!nextCode || nextCode === code) return null;
+			return {
+				code: nextCode,
+				map: null
+			};
+		}
+	}];
+}
+function hasVitePipelineTailwindGenerationDirective(code) {
+	return require_generator.hasTailwindRootDirectives(code) || require_generator.hasTailwindApplyDirective(code);
+}
+//#endregion
+//#region src/bundlers/vite/runtime-class-set.ts
+function createViteRuntimeClassSet(options) {
+	const { opts, initialTailwindRuntime, refreshTailwindcssRuntime, uniAppXEnabled, customAttributesEntities, disabledDefaultTemplateHandler, debug } = options;
+	const readyPromise = require_compiler.createTailwindRuntimeReadyPromise(initialTailwindRuntime);
+	const runtimeState = require_runtime_state.createCompilerRuntimeState({
+		tailwindRuntime: initialTailwindRuntime,
+		readyPromise,
+		refreshTailwindcssRuntime
+	});
+	const bundleRuntimeClassSetManager = require_hmr_timing.createRuntimeClassSetManager({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		escapeMap: opts.escapeMap
+	});
+	const transformRuntimeClassSetManager = require_hmr_timing.createRuntimeClassSetManager({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		escapeMap: opts.escapeMap
+	});
+	let runtimeSet;
+	let runtimeSetPromise;
+	let runtimeRefreshSignature;
+	let runtimeRefreshOptionsKey;
+	function resolveRuntimeRefreshOptions() {
+		const configPath = require_generator.resolveTailwindcssOptions(runtimeState.tailwindRuntime.options)?.config;
+		const signature = require_tailwindcss.getRuntimeClassSetSignature(runtimeState.tailwindRuntime);
+		const optionsKey = JSON.stringify({
+			appType: opts.appType,
+			uniAppX: uniAppXEnabled,
+			customAttributesEntities,
+			disabledDefaultTemplateHandler,
+			configPath
+		});
+		const changed = signature !== runtimeRefreshSignature || optionsKey !== runtimeRefreshOptionsKey;
+		runtimeRefreshSignature = signature;
+		runtimeRefreshOptionsKey = optionsKey;
+		return {
+			changed,
+			signature,
+			optionsKey
+		};
+	}
+	async function refreshRuntimeState(force) {
+		const invalidation = resolveRuntimeRefreshOptions();
+		const shouldRefresh = force || invalidation.changed;
+		const refreshed = await require_compiler.refreshTailwindRuntimeState(runtimeState, {
+			force: shouldRefresh,
+			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.readyPromise;
+		if (!forceRuntimeRefresh && runtimeSet) return runtimeSet;
+		if (forceRuntimeRefresh || !runtimeSetPromise) {
+			const invalidation = resolveRuntimeRefreshOptions();
+			runtimeSetPromise = require_compiler.collectRuntimeClassSet(runtimeState.tailwindRuntime, {
+				force: forceRuntimeRefresh || invalidation.changed,
+				skipRefresh: forceRuntimeRefresh,
+				clearCache: forceRuntimeRefresh || invalidation.changed
+			});
+		}
+		const task = runtimeSetPromise;
+		try {
+			runtimeSet = await task;
+			return runtimeSet;
+		} finally {
+			if (runtimeSetPromise === task) runtimeSetPromise = void 0;
+		}
+	}
+	async function ensureBundleRuntimeClassSet(snapshot, forceRefresh = false, options = {}) {
+		const forceRuntimeRefresh = forceRefresh || node_process.default.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1";
+		const invalidation = resolveRuntimeRefreshOptions();
+		const shouldRefreshRuntime = forceRuntimeRefresh || invalidation.changed;
+		const forceCollectBySource = snapshot.runtimeAffectingChangedByType.html.size > 0 || snapshot.runtimeAffectingChangedByType.js.size > 0;
+		await refreshRuntimeState(shouldRefreshRuntime);
+		await runtimeState.readyPromise;
+		if (shouldRefreshRuntime) {
+			runtimeSet = void 0;
+			runtimeSetPromise = void 0;
+			await bundleRuntimeClassSetManager.reset();
+			await transformRuntimeClassSetManager.reset();
+		}
+		if (!forceRuntimeRefresh) try {
+			const baseClassSet = options.baseClassSet ?? runtimeSet ?? await require_compiler.collectRuntimeClassSet(runtimeState.tailwindRuntime, {
+				force: invalidation.changed,
+				clearCache: invalidation.changed
+			});
+			const nextRuntimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.tailwindRuntime, snapshot, {
+				baseClassSet,
+				skipInitialFullScanWithBase: options.allowBaselineOnlyInitialSync
+			});
+			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_compiler.collectRuntimeClassSet(runtimeState.tailwindRuntime, {
+			force: forceRuntimeRefresh || invalidation.changed || forceCollectBySource,
+			skipRefresh: forceRuntimeRefresh,
+			clearCache: forceRuntimeRefresh || invalidation.changed
+		});
+		runtimeSetPromise = task;
+		try {
+			runtimeSet = await task;
+			return runtimeSet;
+		} finally {
+			if (runtimeSetPromise === task) runtimeSetPromise = void 0;
+		}
+	}
+	return {
+		runtimeState,
+		refreshRuntimeState,
+		ensureRuntimeClassSet,
+		ensureBundleRuntimeClassSet
+	};
+}
+//#endregion
+//#region src/bundlers/vite/serve-css-generation.ts
+const SPECIAL_QUERY_RE = /[?&](?:worker|sharedworker|raw|url)\b/;
+const COMMON_JS_PROXY_RE = /\?commonjs-proxy/;
+const VITE_CSS_HMR_MODULE_RE = /\b__vite__updateStyle\s*\(/;
+const VITE_CSS_CONST_RE = /\bconst\s+__vite__css\s*=\s*("(?:\\[\s\S]|[^"])*")/;
+const DEFERRED_CSS_HMR_QUERY_RE = /[?&](?:hmr(?:[=&]|$)|t=\d+)/;
+function decodeJsStringLiteral(literal) {
+	try {
+		return JSON.parse(literal);
+	} catch {
+		return;
+	}
+}
+function encodeJsStringLiteral(value) {
+	return JSON.stringify(value);
+}
+function extractViteCssHmrModuleCss(code) {
+	const match = VITE_CSS_CONST_RE.exec(code);
+	if (!match?.[1]) return;
+	const css = decodeJsStringLiteral(match[1]);
+	if (typeof css !== "string") return;
+	return {
+		css,
+		start: match.index + match[0].lastIndexOf(match[1]),
+		end: match.index + match[0].length
+	};
+}
+function replaceViteCssHmrModuleCss(code, css) {
+	const extracted = extractViteCssHmrModuleCss(code);
+	if (!extracted) return;
+	return `${code.slice(0, extracted.start)}${encodeJsStringLiteral(css)}${code.slice(extracted.end)}`;
+}
+function isViteServeStyleRequest(id, command) {
+	return command === "serve" && require_v4_generation_core.isSourceStyleRequest(id) && !SPECIAL_QUERY_RE.test(id) && !COMMON_JS_PROXY_RE.test(id);
+}
+function isViteServeCssRootRequest(id, command) {
+	return command === "serve" && require_v4_generation_core.isSourceStyleRequest(id) && !SPECIAL_QUERY_RE.test(id) && !COMMON_JS_PROXY_RE.test(id);
+}
+function isViteBuildStyleRequest(id, command) {
+	return command === "build" && require_v4_generation_core.isSourceStyleRequest(id) && !SPECIAL_QUERY_RE.test(id) && !COMMON_JS_PROXY_RE.test(id);
+}
+function isViteCssHmrModule(code, id, command) {
+	return isViteServeStyleRequest(id, command) && VITE_CSS_HMR_MODULE_RE.test(code) && (/[?&](?:direct|vue)(?:&|$)/.test(id) || DEFERRED_CSS_HMR_QUERY_RE.test(id));
+}
+function hasViteCssGenerationDirective(code) {
+	return require_generator.hasTailwindRootDirectives(code) || require_generator.hasTailwindSourceDirectives(code, { importFallback: true }) || require_generator.hasTailwindApplyDirective(code);
+}
+function hasViteServeCssRootDirective(code) {
+	return require_generator.hasTailwindRootDirectives(code);
+}
+function createViteCssGenerationPlugins(options) {
+	return [
+		{
+			name: `${require_compiler.vitePluginName}:generate:serve`,
+			apply: "serve",
+			enforce: "pre",
+			async transform(code, id) {
+				if (!options.shouldGenerate() || !isViteServeCssRootRequest(id, options.getCommand())) return;
+				if (!require_generator.hasTailwindRootDirectives(code)) return;
+				if (DEFERRED_CSS_HMR_QUERY_RE.test(id)) return;
+				await options.onTailwindRootCss?.(id, code);
+				const generatedCss = await options.generateCss(id, code, {
+					...this.addWatchFile ? { addWatchFile: this.addWatchFile.bind(this) } : {},
+					...this.emitFile ? { emitFile: this.emitFile.bind(this) } : {},
+					cssStage: "raw"
+				});
+				if (generatedCss === void 0 || generatedCss === code) return;
+				return {
+					code: generatedCss,
+					map: null
+				};
+			}
+		},
+		{
+			name: `${require_compiler.vitePluginName}:generate:build`,
+			apply: "build",
+			enforce: "pre",
+			async transform(code, id) {
+				if (!options.shouldGenerate() || options.shouldGenerateBuild?.() === false || !isViteBuildStyleRequest(id, options.getCommand())) return;
+				if (!hasViteCssGenerationDirective(code)) return;
+				if (options.shouldDeferGeneration?.(id, code)) return;
+				if (hasViteServeCssRootDirective(code)) await options.onTailwindRootCss?.(id, code);
+				const generatedCss = await options.generateCss(id, code, {
+					...this.addWatchFile ? { addWatchFile: this.addWatchFile.bind(this) } : {},
+					...this.emitFile ? { emitFile: this.emitFile.bind(this) } : {},
+					cssStage: "raw"
+				});
+				if (generatedCss === void 0 || generatedCss === code) return;
+				return {
+					code: generatedCss,
+					map: null
+				};
+			}
+		},
+		{
+			name: `${require_compiler.vitePluginName}:generate:serve-hmr`,
+			apply: "serve",
+			enforce: "post",
+			async transform(code, id) {
+				if (!options.shouldGenerate() || !isViteCssHmrModule(code, id, options.getCommand())) return;
+				const extracted = extractViteCssHmrModuleCss(code);
+				if (!extracted) return;
+				if (!hasViteCssGenerationDirective(extracted.css)) return;
+				if (options.shouldDeferGeneration?.(id, extracted.css)) return;
+				if (hasViteServeCssRootDirective(extracted.css)) await options.onTailwindRootCss?.(id, extracted.css);
+				const generatedCss = await options.generateCss(id, extracted.css, {
+					...this.addWatchFile ? { addWatchFile: this.addWatchFile.bind(this) } : {},
+					...this.emitFile ? { emitFile: this.emitFile.bind(this) } : {},
+					cssStage: "framework-processed"
+				});
+				if (generatedCss === void 0 || generatedCss === extracted.css) return;
+				const nextCode = replaceViteCssHmrModuleCss(code, generatedCss);
+				if (nextCode === void 0 || nextCode === code) return;
+				return {
+					code: nextCode,
+					map: null
+				};
+			}
+		}
+	];
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-css-generation-queue.ts
+function createFrameworkCssGenerationQueue(normalizeId, generate) {
+	const pendingByFile = /* @__PURE__ */ new Map();
+	return (id, ...args) => {
+		const fileKey = normalizeId(id);
+		const task = (pendingByFile.get(fileKey) ?? Promise.resolve()).then(() => generate(id, ...args));
+		const tail = task.then(() => void 0, () => void 0);
+		pendingByFile.set(fileKey, tail);
+		tail.then(() => {
+			if (pendingByFile.get(fileKey) === tail) pendingByFile.delete(fileKey);
+		});
+		return task;
+	};
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-hmr-candidate-state.ts
+function createViteHmrCandidateState(options) {
+	let pendingChange;
+	let pendingCssTargetFiles;
+	let pendingTargetsArmed = false;
+	let pendingFullRegeneration = false;
+	const normalizeCssTargetFile = (file) => normalizeVitePersistentCacheKey((0, _weapp_tailwindcss_shared.cleanUrl)(file));
+	const clear = () => {
+		pendingChange = void 0;
+		pendingCssTargetFiles = void 0;
+		pendingTargetsArmed = false;
+		pendingFullRegeneration = false;
+	};
+	const queueFullRegeneration = () => {
+		pendingChange = void 0;
+		pendingCssTargetFiles = void 0;
+		pendingTargetsArmed = false;
+		pendingFullRegeneration = true;
+	};
+	const queueChange = (change) => {
+		var _pendingChange;
+		if (pendingFullRegeneration) return;
+		pendingFullRegeneration = false;
+		if (!pendingChange) {
+			pendingChange = {
+				file: change.file,
+				runtimeAffecting: change.runtimeAffecting,
+				addedCandidates: new Set(change.addedCandidates),
+				removedCandidates: new Set(change.removedCandidates)
+			};
+			return;
+		}
+		for (const candidate of change.addedCandidates) {
+			pendingChange.addedCandidates.add(candidate);
+			pendingChange.removedCandidates.delete(candidate);
+		}
+		for (const candidate of change.removedCandidates) if (!pendingChange.addedCandidates.delete(candidate)) pendingChange.removedCandidates.add(candidate);
+		(_pendingChange = pendingChange).runtimeAffecting || (_pendingChange.runtimeAffecting = change.runtimeAffecting);
+		pendingChange.file = change.file;
+	};
+	const createChange = (file, change, changeOptions = {}) => ({
+		...change,
+		file,
+		runtimeAffecting: changeOptions.runtimeAffecting === true || options.isRuntimeAffectingSource?.(file) === true || require_v4_generation_core.isSourceStyleRequest(file)
+	});
+	const apply = (change) => {
+		if (require_v4_generation_core.isSourceStyleRequest(change.file)) {
+			clear();
+			return change;
+		}
+		if (change.runtimeAffecting) {
+			queueFullRegeneration();
+			return change;
+		}
+		const preserveDeletedCss = options.getGeneratorOptions().hmr.preserveDeletedCss;
+		if (preserveDeletedCss) {
+			if (change.addedCandidates.size > 0) queueChange(change);
+			else if (!pendingChange && !pendingFullRegeneration) clear();
+			return change;
+		}
+		clear();
+		if (!preserveDeletedCss) queueFullRegeneration();
+		return change;
+	};
+	const resolve = (generatorCode, file) => {
+		const fileKey = normalizeCssTargetFile(file);
+		if (options.getCommand() !== "serve" || !pendingChange || pendingChange.runtimeAffecting || pendingChange.addedCandidates.size === 0 || options.getGeneratorOptions().target === "weapp" && require_generator.hasUserCssLayerBlocks(generatorCode) || !options.cleanGeneratedCssByFile.has(fileKey) || !options.generatedClassSetByFile.has(fileKey) || pendingTargetsArmed && !pendingCssTargetFiles?.has(fileKey)) return;
+		return pendingChange;
+	};
+	const finishTarget = (file) => {
+		if (!pendingChange && !pendingFullRegeneration) return;
+		if (!pendingTargetsArmed || !pendingCssTargetFiles) return;
+		pendingCssTargetFiles.delete(normalizeCssTargetFile(file));
+		if (pendingCssTargetFiles.size === 0) clear();
+	};
+	const armTargets = (cssModules, fallbackCssIds) => {
+		if (!pendingChange && !pendingFullRegeneration) {
+			pendingCssTargetFiles = void 0;
+			pendingTargetsArmed = false;
+			return;
+		}
+		const targets = /* @__PURE__ */ new Set();
+		const addTarget = (file) => {
+			if (!file) return;
+			const key = normalizeCssTargetFile(file);
+			if (pendingFullRegeneration || options.cleanGeneratedCssByFile.has(key)) targets.add(key);
+		};
+		for (const module of cssModules) {
+			addTarget(module.id);
+			addTarget(module.file);
+			addTarget(module.url);
+		}
+		for (const id of fallbackCssIds) addTarget(id);
+		pendingCssTargetFiles = targets;
+		pendingTargetsArmed = true;
+	};
+	const reconcileRuntimeCandidates = (file, candidates, rootCssIds) => {
+		if (options.getCommand() !== "serve" || pendingFullRegeneration) return;
+		const generatedClassSets = [];
+		const seenFiles = /* @__PURE__ */ new Set();
+		for (const id of rootCssIds) {
+			const fileKey = normalizeCssTargetFile(id);
+			if (seenFiles.has(fileKey)) continue;
+			seenFiles.add(fileKey);
+			const classSet = options.generatedClassSetByFile.get(fileKey);
+			if (classSet) generatedClassSets.push(classSet);
+		}
+		if (generatedClassSets.length === 0) return;
+		const addedCandidates = /* @__PURE__ */ new Set();
+		for (const candidate of candidates) if (generatedClassSets.some((classSet) => !classSet.has(candidate))) addedCandidates.add(candidate);
+		if (addedCandidates.size === 0) return;
+		apply(createChange(file, {
+			addedCandidates,
+			removedCandidates: /* @__PURE__ */ new Set()
+		}));
+	};
+	return {
+		apply,
+		armTargets,
+		clear,
+		createChange,
+		finishTarget,
+		hasPendingCandidateAppend: () => pendingChange != null && !pendingChange.runtimeAffecting && pendingChange.addedCandidates.size > 0,
+		hasPendingChange: () => pendingChange != null || pendingFullRegeneration,
+		queueFullRegeneration,
+		reconcileRuntimeCandidates,
+		resolve,
+		shouldForceFullRegeneration: (file, resolved) => {
+			if (options.getCommand() !== "serve") return false;
+			if (pendingFullRegeneration) return pendingTargetsArmed && pendingCssTargetFiles?.has(normalizeCssTargetFile(file)) === true;
+			return pendingChange != null && !resolved && pendingTargetsArmed && pendingCssTargetFiles?.has(normalizeCssTargetFile(file)) === true;
+		},
+		snapshotDebugState: () => ({
+			pendingAddedCandidates: pendingChange?.addedCandidates.size ?? 0,
+			pendingCssTargets: pendingCssTargetFiles?.size ?? 0,
+			pendingFullRegeneration
+		})
+	};
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-hmr-module-version.ts
+function acceptVersion(versions, keys, timestamp) {
+	if (keys.some((key) => (versions.get(key) ?? 0) > timestamp)) return false;
+	for (const key of keys) versions.set(key, Math.max(versions.get(key) ?? 0, timestamp));
+	return true;
+}
+function createViteHmrCssModuleVersionTracker() {
+	const versions = /* @__PURE__ */ new Map();
+	const keysForId = (id, root) => [resolveViteModuleIdentity(id, root).key];
+	const keysForModule = (mod, root) => [...new Set([
+		mod.id,
+		mod.url,
+		mod.file
+	].filter((id) => typeof id === "string" && id.length > 0).flatMap((id) => keysForId(id, root)))];
+	return {
+		clear() {
+			versions.clear();
+		},
+		filterIds(ids, timestamp, root) {
+			return [...ids].filter((id) => acceptVersion(versions, keysForId(id, root), timestamp));
+		},
+		filterModules(modules, timestamp, root) {
+			return modules.filter((mod) => {
+				const keys = keysForModule(mod, root);
+				return keys.length === 0 || acceptVersion(versions, keys, timestamp);
+			});
+		},
+		reserveRefreshTimestamp(modules, timestamp, root) {
+			const moduleKeys = modules.flatMap((mod) => keysForModule(mod, root));
+			const latestTimestamp = moduleKeys.reduce((latest, key) => Math.max(latest, versions.get(key) ?? 0), 0);
+			const refreshTimestamp = Math.max(Date.now(), timestamp + 1, latestTimestamp + 1);
+			for (const key of moduleKeys) versions.set(key, refreshTimestamp);
+			return refreshTimestamp;
+		}
+	};
+}
+function createViteHmrCssModuleVersionFilterPlugin(tracker) {
+	return {
+		name: "weapp-tailwindcss:hmr-css-module-version",
+		enforce: "post",
+		handleHotUpdate: {
+			order: "post",
+			handler(ctx) {
+				const styleModules = ctx.modules.filter((mod) => {
+					const request = mod.id ?? mod.url;
+					return require_v4_generation_core.isSourceStyleRequest(request);
+				});
+				if (styleModules.length === 0) return;
+				const root = ctx.server.config?.root ?? node_process.default.cwd();
+				const currentStyleModules = tracker.filterModules(styleModules, ctx.timestamp, root);
+				if (currentStyleModules.length === styleModules.length) return;
+				const droppedStyleModules = styleModules.filter((mod) => !currentStyleModules.includes(mod));
+				for (const mod of droppedStyleModules) ctx.server.moduleGraph.invalidateModule(mod);
+				const refreshTimestamp = tracker.reserveRefreshTimestamp(droppedStyleModules, ctx.timestamp, root);
+				sendSupplementalCssHotUpdates({
+					...ctx,
+					timestamp: refreshTimestamp
+				}, droppedStyleModules, [], [], []);
+				return [...ctx.modules.filter((mod) => !styleModules.includes(mod)), ...currentStyleModules];
+			}
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/vite/official-tailwind-plugins.ts
+function isTailwindVitePlugin(plugin) {
+	if (!plugin || typeof plugin !== "object" || !("name" in plugin)) return false;
+	const { name } = plugin;
+	return typeof name === "string" && name.startsWith("@tailwindcss/vite");
+}
+function removeTailwindVitePlugins(plugins) {
+	let removed = 0;
+	for (let i = plugins.length - 1; i >= 0; i--) if (isTailwindVitePlugin(plugins[i])) {
+		plugins.splice(i, 1);
+		removed++;
+	}
+	return removed;
+}
+function disableTailwindVitePlugin(plugin) {
+	if (!isTailwindVitePlugin(plugin)) return false;
+	const mutablePlugin = plugin;
+	for (const hook of [
+		"configResolved",
+		"configureServer",
+		"transform",
+		"hotUpdate",
+		"handleHotUpdate"
+	]) delete mutablePlugin[hook];
+	return true;
+}
+function disableAndRemoveTailwindVitePlugins(plugins) {
+	let removed = 0;
+	for (let i = plugins.length - 1; i >= 0; i--) {
+		const plugin = plugins[i];
+		if (Array.isArray(plugin)) {
+			removed += disableAndRemoveTailwindVitePlugins(plugin);
+			if (plugin.length === 0) plugins.splice(i, 1);
+			continue;
+		}
+		if (disableTailwindVitePlugin(plugin)) {
+			plugins.splice(i, 1);
+			removed++;
+		}
+	}
+	return removed;
+}
+//#endregion
+//#region src/bundlers/vite/tailwind-basedir.ts
+const PACKAGE_JSON_FILE = "package.json";
+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_tailwindcss.findTailwindConfig(searchRoots);
+	if (tailwindConfigPath) return node_path.default.dirname(tailwindConfigPath);
+	const packageRoot = require_generator.findNearestPackageRoot(resolvedRoot);
+	if (packageRoot && (0, node_fs.existsSync)(node_path.default.join(packageRoot, PACKAGE_JSON_FILE))) return packageRoot;
+	return resolvedRoot;
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-post-plugin.ts
+function createFrameworkPostPlugin(options) {
+	const plugin = {
+		name: `${require_compiler.vitePluginName}:post`,
+		enforce: "post",
+		config(config) {
+			if (!options.shouldOwnTailwindGeneration) return;
+			if (Array.isArray(config.plugins)) {
+				const removed = disableAndRemoveTailwindVitePlugins(config.plugins);
+				if (removed > 0) {
+					_weapp_tailwindcss_logger.logger.warn("检测到 @tailwindcss/vite，生成模式下已移除该插件以避免 Tailwind CSS 重复生成。");
+					options.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: options.generatorPlaceholderCssFile
+			}] } };
+			if (config.css?.postcss !== void 0) return baseConfig;
+			return (0, _weapp_tailwindcss_postcss.resolvePostcssConfig)(root).then((postcssConfig) => {
+				if (!postcssConfig) return baseConfig;
+				const plugins = [...postcssConfig.plugins];
+				const removed = (0, _weapp_tailwindcss_postcss.removeTailwindPostcssPlugins)(plugins);
+				if (removed > 0) options.debug("inline filtered postcss config without official tailwind plugins in generator mode: %d", removed);
+				return {
+					...baseConfig,
+					css: { postcss: {
+						...postcssConfig.options,
+						plugins
+					} }
+				};
+			});
+		},
+		async configResolved(config) {
+			await options.hmrTimingRecorder.measure("configResolved", async () => {
+				options.setResolvedConfig(config);
+				if (options.shouldOwnTailwindGeneration) {
+					const removed = Array.isArray(config.plugins) ? removeTailwindVitePlugins(config.plugins) : 0;
+					if (removed > 0) options.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 (!options.hasExplicitTailwindcssBasedir && resolvedRoot) {
+					const nextTailwindcssBasedir = resolveImplicitTailwindcssBasedirFromViteRoot(resolvedRoot);
+					if (options.opts.tailwindcssBasedir !== nextTailwindcssBasedir) {
+						const previousBasedir = options.opts.tailwindcssBasedir;
+						options.opts.tailwindcssBasedir = nextTailwindcssBasedir;
+						shouldRefreshRuntime = options.syncCssEntriesFromAnchor(nextTailwindcssBasedir) || shouldRefreshRuntime;
+						options.debug("align tailwindcss basedir with vite root: %s -> %s", previousBasedir ?? "undefined", nextTailwindcssBasedir);
+						shouldRefreshRuntime = true;
+					}
+				}
+				if (options.shouldInferAppType && resolvedRoot) {
+					const nextAppType = require_framework.resolveImplicitAppTypeFromViteRoot(resolvedRoot, { searchUp: false });
+					if (nextAppType && options.opts.appType !== nextAppType) {
+						const previousAppType = options.opts.appType;
+						options.opts.appType = nextAppType;
+						_weapp_tailwindcss_logger.logger.debug("根据 Vite 项目根目录自动推断 appType -> %s", nextAppType);
+						options.debug("align appType with vite root: %s -> %s", previousAppType ?? "undefined", nextAppType);
+						shouldRefreshRuntime = true;
+					}
+				}
+				if (options.frameworkName === "generic" && !options.hasExplicitGeneratorTarget && options.opts.generator !== false && options.opts.appType === void 0 && options.opts.platform === void 0 && options.opts.cssOptions?.platform === void 0 && !options.resolveViteStylePlatform()) {
+					const generator = options.opts.generator && typeof options.opts.generator === "object" ? options.opts.generator : {};
+					options.opts.generator = {
+						...generator,
+						target: "web"
+					};
+					_weapp_tailwindcss_logger.logger.debug("Generic Vite 项目未指定目标，自动使用 generator.target -> web");
+					options.debug("default generic vite generator target to web after configResolved");
+					shouldRefreshRuntime = true;
+				}
+				if (shouldRefreshRuntime) await options.refreshRuntimeState(true);
+				if (typeof config.css.postcss === "object" && Array.isArray(config.css.postcss.plugins)) {
+					const postcssPlugins = config.css.postcss.plugins;
+					if (options.shouldOwnTailwindGeneration) {
+						const removed = (0, _weapp_tailwindcss_postcss.removeTailwindPostcssPlugins)(postcssPlugins);
+						if (removed > 0) {
+							_weapp_tailwindcss_logger.logger.warn("检测到 @tailwindcss/postcss，生成模式下已移除该插件以避免 Tailwind CSS 重复生成。");
+							options.debug("remove official tailwind postcss plugins in generator mode: %d", removed);
+						}
+					}
+				}
+				require_v4_generation_core.captureFrameworkPostcssOptions(options.opts, config.css?.postcss && typeof config.css.postcss === "object" ? config.css.postcss : void 0);
+			}, { emit: false });
+		}
+	};
+	if (typeof options.generateBundleHook === "function") plugin.generateBundle = {
+		order: "post",
+		handler: options.generateBundleHook
+	};
+	if (options.api) plugin.api = options.api;
+	return plugin;
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-processed-css-registry.ts
+function createFrameworkProcessedCssRegistry() {
+	const results = /* @__PURE__ */ new Map();
+	const sourceFiles = /* @__PURE__ */ new Set();
+	const markSource = (file) => {
+		sourceFiles.add(node_path.default.resolve((0, _weapp_tailwindcss_shared.cleanUrl)(file)));
+	};
+	const record = (file, css, options = {}) => {
+		const key = normalizeVitePersistentCacheKey(file);
+		const previous = results.get(key);
+		const injectIntoMain = previous?.injectIntoMain === true ? true : options.injectIntoMain ?? previous?.injectIntoMain;
+		touchMapEntry(results, key, {
+			css,
+			injectIntoMain,
+			outputFile: options.outputFile ?? previous?.outputFile
+		});
+	};
+	const get = (file) => results.get(normalizeVitePersistentCacheKey(file));
+	const matchesIdentity = (candidate) => {
+		return sourceFiles.has(node_path.default.resolve((0, _weapp_tailwindcss_shared.cleanUrl)(candidate)));
+	};
+	const prune = (activeFiles) => {
+		for (const [key, result] of results) {
+			const outputKey = result.outputFile ? normalizeVitePersistentCacheKey(result.outputFile) : void 0;
+			if (!activeFiles.has(key) && (outputKey == null || !activeFiles.has(outputKey))) results.delete(key);
+		}
+	};
+	return {
+		entries: () => results.entries(),
+		get,
+		getStats: () => ({
+			viteProcessedCssAssetResults: results.size,
+			viteProcessedCssAssetResultsRaw: summarizeViteProcessedCssResults(results)
+		}),
+		markSource,
+		matchesIdentity,
+		prune,
+		record,
+		sourceFiles
+	};
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-hmr-runtime-signature.ts
+const WEB_HMR_RUNTIME_AFFECTING_DIRECTIVE_RE = /@(?:theme|source|config|plugin|apply)\b/;
+function createFrameworkHmrRuntimeSignature(file, source) {
+	if (!source || !WEB_HMR_RUNTIME_AFFECTING_DIRECTIVE_RE.test(source)) return "";
+	return (isSfcStyleSourceFile((0, _weapp_tailwindcss_shared.cleanUrl)(file)) ? extractSfcStyleSources(source).filter((styleSource) => WEB_HMR_RUNTIME_AFFECTING_DIRECTIVE_RE.test(styleSource)) : [source]).map((styleSource) => require_compiler.createRuntimeAffectingSourceSignature(styleSource, "css")).join("\0");
+}
+function hasFrameworkHmrRuntimeSourceChange(file, previousSource, nextSource) {
+	return createFrameworkHmrRuntimeSignature(file, previousSource) !== createFrameworkHmrRuntimeSignature(file, nextSource);
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-source-scan-session.ts
+const SOURCE_CANDIDATE_SCAN_CACHE_MAX = 8;
+const sourceCandidateScanSnapshotCache = new lru_cache.LRUCache({ max: SOURCE_CANDIDATE_SCAN_CACHE_MAX });
+async function syncFrameworkSourceCandidatesForHotUpdate(sourceScanSession, ctx) {
+	const source = typeof ctx.read === "function" ? await ctx.read().catch(() => void 0) : void 0;
+	await sourceScanSession.syncChangedFile(ctx.file, source);
+	await sourceScanSession.waitForPendingSyncs();
+}
+function createFrameworkSourceScanSession(options) {
+	const sourceCandidateScanCache = new lru_cache.LRUCache({ max: SOURCE_CANDIDATE_SCAN_CACHE_MAX });
+	let sourceScanEntries;
+	let sourceScanMatcher;
+	let sourceScanBoundaryMatcher;
+	let sourceScanRoots = [];
+	let sourceScanOutDir;
+	let sourceScanEligibleFiles = /* @__PURE__ */ new Set();
+	let sourceScanEligibleFilesRefresh;
+	const sourceScanIneligibleFiles = /* @__PURE__ */ new Set();
+	let sourceScanDependencies = /* @__PURE__ */ new Set();
+	let sourceScanExplicit = false;
+	let sourceCandidateScanSignature;
+	let sourceCandidateScanInvalidated = true;
+	const pendingSourceCandidateSyncs = /* @__PURE__ */ new Set();
+	const pendingSourceCandidateSyncByFile = /* @__PURE__ */ new Map();
+	const pendingHotUpdateChangeByFile = /* @__PURE__ */ new Map();
+	const pendingChangedFiles = /* @__PURE__ */ new Map();
+	let pendingChangedFilesFlush;
+	let isFlushingChangedFiles = false;
+	let cacheDirty = false;
+	let cachedCollectorRevision;
+	const normalizeDependency = (file) => node_path.default.normalize(node_path.default.resolve((0, _weapp_tailwindcss_shared.cleanUrl)(file)));
+	const isDependency = (file) => sourceScanDependencies.has(normalizeDependency(file));
+	const invalidate = () => {
+		sourceCandidateScanInvalidated = true;
+		sourceScanIneligibleFiles.clear();
+	};
+	const hasState = () => sourceCandidateScanSignature !== void 0;
+	const collectRoots = (root, entries) => {
+		if (entries?.length) return [{
+			entries,
+			explicit: sourceScanExplicit,
+			root
+		}];
+		if (sourceScanExplicit && entries !== void 0) return [];
+		const roots = [{
+			entries,
+			root
+		}];
+		const seenRoots = /* @__PURE__ */ new Set([node_path.default.resolve(root)]);
+		const basedir = options.opts.tailwindcssBasedir ? node_path.default.resolve(options.opts.tailwindcssBasedir) : void 0;
+		if (basedir && !seenRoots.has(basedir)) {
+			roots.push({ root: basedir });
+			seenRoots.add(basedir);
+		}
+		for (const cssEntry of options.opts.tailwindcss?.v4?.cssEntries ?? []) {
+			if (!require_generator.isTailwindV4CssEntry(cssEntry)) continue;
+			const cssEntryRoot = node_path.default.dirname(node_path.default.resolve(cssEntry));
+			if (seenRoots.has(cssEntryRoot)) continue;
+			roots.push({ root: cssEntryRoot });
+			seenRoots.add(cssEntryRoot);
+		}
+		return roots;
+	};
+	const cacheCurrent = () => {
+		if (!sourceCandidateScanSignature) return;
+		if (isFlushingChangedFiles) {
+			cacheDirty = true;
+			return;
+		}
+		const collectorRevision = options.sourceCandidateCollector.getRevision?.();
+		if (!cacheDirty && cachedCollectorRevision !== void 0 && collectorRevision === cachedCollectorRevision) return;
+		const entry = {
+			eligibleFiles: [...sourceScanEligibleFiles],
+			snapshot: options.sourceCandidateCollector.snapshot()
+		};
+		sourceCandidateScanCache.set(sourceCandidateScanSignature, entry);
+		sourceCandidateScanSnapshotCache.set(sourceCandidateScanSignature, entry);
+		cachedCollectorRevision = collectorRevision;
+		cacheDirty = false;
+	};
+	const updateSourceScanMatchers = (eligibleFiles) => {
+		sourceScanEligibleFiles = new Set(eligibleFiles);
+		const matcherRoots = sourceScanRoots.map((scanRoot) => ({
+			...scanRoot,
+			outDir: sourceScanOutDir
+		}));
+		sourceScanBoundaryMatcher = require_v4_generation_core.createSourceCandidateEligibilityMatcher(matcherRoots);
+		sourceScanMatcher = require_v4_generation_core.createSourceCandidateEligibilityMatcher(matcherRoots, sourceScanEligibleFiles);
+	};
+	const refreshSourceScanEligibleFiles = async () => {
+		sourceScanEligibleFilesRefresh ?? (sourceScanEligibleFilesRefresh = Promise.all(sourceScanRoots.map((scanRoot) => options.sourceCandidateCollector.resolveScanFiles({
+			entries: scanRoot.entries,
+			explicit: scanRoot.explicit,
+			root: scanRoot.root,
+			outDir: sourceScanOutDir
+		}))).then((files) => updateSourceScanMatchers(files.flat())).finally(() => {
+			sourceScanEligibleFilesRefresh = void 0;
+		}));
+		await sourceScanEligibleFilesRefresh;
+	};
+	const shouldDiscoverAutoCssSources = (autoCssSourcesDiscovered) => {
+		if (!autoCssSourcesDiscovered || !options.isWatchLikeBuild()) return true;
+		return sourceCandidateScanInvalidated;
+	};
+	const sync = async (syncOptions = {}) => {
+		if (!options.shouldOwnTailwindGeneration) return;
+		if (!syncOptions.force && options.isWatchLikeBuild() && hasState() && !sourceCandidateScanInvalidated) {
+			options.debug("reuse vite source candidate scan definition for watch rebuild");
+			return;
+		}
+		const resolvedConfig = options.getResolvedConfig();
+		const root = resolvedConfig?.root ?? node_process.default.cwd();
+		const outDir = resolvedConfig?.build?.outDir;
+		const sourceScan = await require_tailwindcss.resolveSourceScanEntries(options.opts, options.runtimeState.tailwindRuntime, {
+			outDir,
+			root
+		});
+		sourceScanEntries = sourceScan?.entries;
+		sourceScanExplicit = sourceScan?.explicit ?? false;
+		sourceScanDependencies = new Set((sourceScan?.dependencies ?? []).map(normalizeDependency));
+		const roots = collectRoots(root, sourceScanEntries);
+		sourceScanRoots = roots;
+		sourceScanOutDir = outDir;
+		const nextScanSignature = require_source_candidate_scan_signature.createSourceCandidateScanSignature({
+			inlineCandidates: sourceScan?.inlineCandidates,
+			outDir,
+			roots,
+			scanAllSources: !sourceScanExplicit
+		});
+		if (hasState() && sourceCandidateScanSignature === nextScanSignature) {
+			options.sourceCandidateCollector.syncInline(sourceScan?.inlineCandidates);
+			cacheCurrent();
+			options.debug("reuse vite source candidate scan for watch rebuild");
+			sourceCandidateScanInvalidated = false;
+			return;
+		}
+		const cachedScan = options.isWatchLikeBuild() ? sourceCandidateScanCache.get(nextScanSignature) ?? sourceCandidateScanSnapshotCache.get(nextScanSignature) : void 0;
+		if (cachedScan) {
+			options.sourceCandidateCollector.restore(cachedScan.snapshot);
+			sourceScanIneligibleFiles.clear();
+			updateSourceScanMatchers(cachedScan.eligibleFiles);
+			sourceCandidateScanSignature = nextScanSignature;
+			options.debug("reuse cached vite source candidate scan for watch rebuild");
+			sourceCandidateScanInvalidated = false;
+			return;
+		}
+		if (options.isWatchLikeBuild()) options.sourceCandidateCollector.resetScan();
+		else options.sourceCandidateCollector.clearScan();
+		options.sourceCandidateCollector.syncInline(sourceScan?.inlineCandidates);
+		const eligibleFiles = /* @__PURE__ */ new Set();
+		sourceScanIneligibleFiles.clear();
+		await Promise.all(roots.map((scanRoot) => options.sourceCandidateCollector.scanRoot({
+			entries: scanRoot.entries,
+			explicit: scanRoot.explicit,
+			root: scanRoot.root,
+			outDir,
+			onFilesResolved: (files) => files.forEach((file) => eligibleFiles.add(file))
+		})));
+		updateSourceScanMatchers(eligibleFiles);
+		sourceCandidateScanSignature = nextScanSignature;
+		sourceCandidateScanInvalidated = false;
+		if (options.isWatchLikeBuild()) cacheCurrent();
+	};
+	const waitForPendingSyncs = async () => {
+		while (true) {
+			if (!pendingChangedFilesFlush && pendingChangedFiles.size === 0 && pendingSourceCandidateSyncs.size === 0) break;
+			await pendingChangedFilesFlush;
+			if (pendingChangedFiles.size > 0) await flushChangedFiles();
+			if (pendingSourceCandidateSyncs.size > 0) await Promise.all(pendingSourceCandidateSyncs);
+		}
+	};
+	const rememberHotUpdateChange = (change) => {
+		if (!change) return;
+		const previous = pendingHotUpdateChangeByFile.get(change.file);
+		if (!previous) {
+			const remembered = {
+				...change,
+				addedCandidates: new Set(change.addedCandidates),
+				removedCandidates: new Set(change.removedCandidates)
+			};
+			pendingHotUpdateChangeByFile.set(change.file, remembered);
+			return remembered;
+		}
+		for (const candidate of change.addedCandidates) {
+			previous.addedCandidates.add(candidate);
+			previous.removedCandidates.delete(candidate);
+		}
+		for (const candidate of change.removedCandidates) if (!previous.addedCandidates.delete(candidate)) previous.removedCandidates.add(candidate);
+		previous.runtimeAffecting || (previous.runtimeAffecting = change.runtimeAffecting);
+		return previous;
+	};
+	const syncChangedFileNow = async (id, sourceOverride, event = "update") => {
+		if (!options.shouldOwnTailwindGeneration || !options.isCandidateRequest(id)) return;
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+		const runtimeAffectingByDependency = isDependency(file);
+		if (runtimeAffectingByDependency) invalidate();
+		const resolvedFile = require_generator.resolveSourceScanPath(file);
+		if (sourceScanMatcher && !sourceScanMatcher(file) && sourceScanBoundaryMatcher?.(file) && !sourceScanIneligibleFiles.has(resolvedFile)) {
+			await refreshSourceScanEligibleFiles();
+			if (!sourceScanMatcher(file)) sourceScanIneligibleFiles.add(resolvedFile);
+		}
+		if (sourceScanMatcher && !sourceScanMatcher(file)) {
+			const change = options.sourceCandidateCollector.remove(file);
+			cacheCurrent();
+			return (require_v4_generation_core.isSourceStyleRequest(file) ? (0, node_fs_promises.readFile)(file, "utf8").then((source) => options.cssMemory.refreshRememberedCssSourceBySourceFile(file, source)).catch((error) => {
+				if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) !== "ENOENT") options.debug("remembered css source watch refresh failed: %s %O", file, error);
+			}) : Promise.resolve()).then(() => options.cssMemory.refreshRememberedCssSourceByCurrentFile(file)).then(() => rememberHotUpdateChange(options.hmrCandidateState.apply(options.hmrCandidateState.createChange(file, change, { runtimeAffecting: true }))));
+		}
+		const existingTask = pendingSourceCandidateSyncByFile.get(file);
+		if (existingTask) {
+			await existingTask;
+			return syncChangedFile(id, sourceOverride);
+		}
+		const previousSource = options.sourceCandidateCollector.source(file);
+		if (event === "delete") {
+			const change = options.sourceCandidateCollector.remove(file);
+			cacheDirty = true;
+			const appliedChange = options.hmrCandidateState.apply(options.hmrCandidateState.createChange(file, change, { runtimeAffecting: runtimeAffectingByDependency }));
+			return rememberHotUpdateChange(appliedChange);
+		}
+		const task = (sourceOverride === void 0 ? options.sourceCandidateCollector.syncCurrentFile(id) : options.sourceCandidateCollector.syncCurrentSource(id, sourceOverride)).catch((error) => {
+			options.debug("source candidate watch sync failed: %s %O", id, error);
+		}).then((change) => {
+			cacheDirty = true;
+			if (!isFlushingChangedFiles) cacheCurrent();
+			const runtimeAffectingBySource = hasFrameworkHmrRuntimeSourceChange(file, previousSource, options.sourceCandidateCollector.source(file));
+			const appliedChange = change ? options.hmrCandidateState.apply(options.hmrCandidateState.createChange(file, change, { runtimeAffecting: runtimeAffectingByDependency || runtimeAffectingBySource })) : void 0;
+			return rememberHotUpdateChange(appliedChange) ?? pendingHotUpdateChangeByFile.get(file);
+		}).finally(() => {
+			pendingSourceCandidateSyncs.delete(task);
+			pendingSourceCandidateSyncByFile.delete(file);
+		});
+		pendingSourceCandidateSyncs.add(task);
+		pendingSourceCandidateSyncByFile.set(file, task);
+		return task.then(async (change) => {
+			await options.cssMemory.refreshRememberedCssSourceByCurrentFile(file);
+			return change;
+		});
+	};
+	const queueChangedFile = (change) => {
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(change.id);
+		const previous = pendingChangedFiles.get(file);
+		if (!previous) {
+			pendingChangedFiles.set(file, {
+				...change,
+				file
+			});
+			return;
+		}
+		previous.event = change.event;
+		if (change.source !== void 0) previous.source = change.source;
+	};
+	const flushChangedFiles = async () => {
+		if (pendingChangedFilesFlush) {
+			const result = await pendingChangedFilesFlush;
+			return pendingChangedFiles.size > 0 ? flushChangedFiles() : result;
+		}
+		if (pendingChangedFiles.size === 0) return /* @__PURE__ */ new Map();
+		const changes = [...pendingChangedFiles.values()];
+		pendingChangedFiles.clear();
+		isFlushingChangedFiles = true;
+		pendingChangedFilesFlush = Promise.all(changes.map(async (change) => [change.file, await syncChangedFileNow(change.file, change.source, change.event)])).then((entries) => new Map(entries)).finally(() => {
+			isFlushingChangedFiles = false;
+			pendingChangedFilesFlush = void 0;
+			cacheCurrent();
+		});
+		return pendingChangedFilesFlush;
+	};
+	const syncChangedFile = async (id, sourceOverride) => {
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+		const existingTask = pendingSourceCandidateSyncByFile.get(file);
+		if (existingTask) {
+			await existingTask;
+			return syncChangedFile(id, sourceOverride);
+		}
+		return syncChangedFileNow(file, sourceOverride);
+	};
+	return {
+		cacheCurrent,
+		consumeHotUpdateChange: (id) => pendingHotUpdateChangeByFile.delete((0, _weapp_tailwindcss_shared.cleanUrl)(id)),
+		getStats: () => ({
+			pendingSourceCandidateSyncByFile: pendingSourceCandidateSyncByFile.size,
+			pendingSourceCandidateSyncs: pendingSourceCandidateSyncs.size,
+			pendingChangedFiles: pendingChangedFiles.size,
+			pendingHotUpdateChangeByFile: pendingHotUpdateChangeByFile.size,
+			sourceCandidateScanCache: sourceCandidateScanCache.size
+		}),
+		invalidate,
+		isDependency,
+		matches: (file) => sourceScanMatcher?.(file) ?? true,
+		queueChangedFile,
+		flushChangedFiles,
+		shouldDiscoverAutoCssSources,
+		sync,
+		syncChangedFile,
+		waitForPendingSyncs
+	};
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-tailwind-root-css.ts
+function createFrameworkTailwindRootCss(options) {
+	const hotSourceByFile = /* @__PURE__ */ new Map();
+	const moduleIds = /* @__PURE__ */ new Set();
+	const normalizeSourceFile = (id) => resolveViteModuleIdentity(id).key;
+	const rememberModule = (id) => {
+		if (!options.shouldOwnTailwindGeneration || typeof id !== "string" || id.length === 0) return;
+		moduleIds.add(id);
+		const identity = resolveViteModuleIdentity(id);
+		if (require_v4_generation_core.isSourceStyleRequest(identity.cleanId)) for (const moduleId of identity.lookupIds) moduleIds.add(moduleId);
+	};
+	const register = async (id, code) => {
+		rememberModule(id);
+		const hotSource = hotSourceByFile.get(normalizeSourceFile(id));
+		await options.registerAutoCssSource(id, hotSource ?? code);
+	};
+	const refreshSource = async (id, code) => {
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+		if (!moduleIds.has(id) && !moduleIds.has(file) && !require_generator.hasTailwindRootDirectives(code, { importFallback: options.getImportFallback() })) return;
+		hotSourceByFile.set(normalizeSourceFile(id), code);
+		await register(id, code);
+		options.sourceScanSession.invalidate();
+		await options.refreshRuntimeState(true);
+		await options.sourceScanSession.sync({ force: true });
+	};
+	return {
+		refreshSource,
+		register,
+		rememberModule,
+		moduleIds
+	};
+}
+//#endregion
+//#region src/style-injector/vite-web.ts
+function getHandler(hook) {
+	if (typeof hook === "function") return hook;
+	if (hook && typeof hook === "object" && typeof hook.handler === "function") return hook.handler;
+}
+/** Generic Web 专用 style injector，避免引入其他构建器和框架适配。 */
+function createBuiltinViteWebStyleInjectorPlugins(options) {
+	const normalized = require_source_candidate_scan_signature.normalizeStyleInjectorOptions(options);
+	if (!normalized) return [];
+	const injector = (0, weapp_style_injector_vite.weappStyleInjector)(normalized);
+	const transform = getHandler(injector.transform);
+	const generateBundle = getHandler(injector.generateBundle);
+	return [{
+		name: "weapp-tailwindcss:web-style-injector-pre",
+		apply: "build",
+		enforce: "pre",
+		configResolved(config) {
+			injector.configResolved?.(config);
+		},
+		async buildStart() {
+			await injector.buildStart?.call(this, {});
+		},
+		async transform(code, id, options2) {
+			return transform?.call(this, code, id, options2);
+		}
+	}, {
+		name: "weapp-tailwindcss:web-style-injector",
+		apply: "build",
+		enforce: "post",
+		configResolved(config) {
+			injector.configResolved?.(config);
+		},
+		async generateBundle(outputOptions, bundle, isWrite) {
+			await generateBundle?.call(this, outputOptions, bundle, isWrite);
+		}
+	}];
+}
+//#endregion
+//#region src/bundlers/vite/shared/create-css-only-plugins-runtime.ts
+const debug = require_compiler.createDebug();
+function resolveWebGeneratorOptions(opts) {
+	return require_generator.normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+		appType: void 0,
+		platform: "web",
+		tailwindcssMajorVersion: opts.tailwindRuntime.majorVersion,
+		uniAppX: false
+	});
+}
+/** 创建不含 JS/template、分包和小程序 bundle 处理的 Generic Web Vite 插件。 */
+function createCssOnlyVitePlugins(options = {}) {
+	const rawOptions = options;
+	const opts = "tailwindRuntime" in options ? options : require_compiler.getCompilerContext({
+		...rawOptions,
+		appType: void 0,
+		platform: "web",
+		generator: rawOptions.generator && typeof rawOptions.generator === "object" ? {
+			...rawOptions.generator,
+			target: "web"
+		} : { target: "web" },
+		__internalDeferMissingCssEntriesWarning: true,
+		__internalViteDeferRuntimeLogs: true
+	});
+	const disabled = opts.disabled === true || typeof opts.disabled === "object" && opts.disabled.plugin === true;
+	const shouldGenerate = !disabled && resolveWebGeneratorOptions(opts).enabled;
+	const sourceCandidateCollector = require_v4_generation_core.createSourceCandidateCollector({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		customAttributesEntities: opts.customAttributesEntities,
+		disabledDefaultTemplateHandler: opts.disabledDefaultTemplateHandler
+	});
+	const cssMemory = createViteCssMemory({
+		debug,
+		getSourceCandidateSource: (file) => sourceCandidateCollector.source(file)
+	});
+	const hmrCssModuleVersions = createViteHmrCssModuleVersionTracker();
+	const hmrTimingRecorder = require_hmr_timing.createHmrTimingRecorder("vite");
+	const { runtimeState, ensureRuntimeClassSet, refreshRuntimeState } = createViteRuntimeClassSet({
+		opts,
+		initialTailwindRuntime: opts.tailwindRuntime,
+		refreshTailwindcssRuntime: opts.refreshTailwindcssRuntime,
+		uniAppXEnabled: false,
+		customAttributesEntities: opts.customAttributesEntities,
+		disabledDefaultTemplateHandler: opts.disabledDefaultTemplateHandler,
+		debug
+	});
+	const hmrCandidateState = createViteHmrCandidateState({
+		cleanGeneratedCssByFile: /* @__PURE__ */ new Map(),
+		generatedClassSetByFile: /* @__PURE__ */ new Map(),
+		getCommand: () => resolvedConfig?.command,
+		getGeneratorOptions: () => resolveWebGeneratorOptions(opts),
+		isRuntimeAffectingSource: () => false
+	});
+	let resolvedConfig;
+	let recordedCandidates;
+	const processedCssRegistry = createFrameworkProcessedCssRegistry();
+	const processedCssAssets = /* @__PURE__ */ new WeakSet();
+	const tailwindRootCssModuleIds = /* @__PURE__ */ new Set();
+	const sourceScanSession = createFrameworkSourceScanSession({
+		cssMemory,
+		debug,
+		getResolvedConfig: () => resolvedConfig,
+		hmrCandidateState,
+		isCandidateRequest: require_v4_generation_core.isSourceCandidateRequest,
+		isWatchLikeBuild: () => resolvedConfig?.command === "serve" || resolvedConfig?.build.watch != null,
+		opts,
+		runtimeState,
+		shouldOwnTailwindGeneration: shouldGenerate,
+		sourceCandidateCollector
+	});
+	const { refreshSource: refreshTailwindRootCssSource, register: registerTailwindRootCss, rememberModule: rememberTailwindRootCssModule } = createFrameworkTailwindRootCss({
+		getImportFallback: () => resolveWebGeneratorOptions(opts).importFallback,
+		refreshRuntimeState: async () => {
+			await refreshRuntimeState(true);
+		},
+		registerAutoCssSource: async (id, css) => {
+			cssMemory.refreshRememberedCssSourceBySourceFile(id, require_generator.normalizeTailwindSourceForGenerator(require_generator.normalizeTailwindConfigDirectives(css, node_path.default.dirname((0, _weapp_tailwindcss_shared.cleanUrl)(id))), { importFallback: true }));
+		},
+		shouldOwnTailwindGeneration: shouldGenerate,
+		sourceScanSession
+	});
+	const cssHandlerOptions = createCssHandlerOptionsCache({
+		getAppType: () => void 0,
+		mainCssChunkMatcher: opts.mainCssChunkMatcher,
+		getMajorVersion: () => runtimeState.tailwindRuntime.majorVersion,
+		getOutputRoot: () => resolvedConfig?.root
+	});
+	const generatedCssByFile = /* @__PURE__ */ new Map();
+	const generateCss = createFrameworkCssGenerationQueue((id) => (0, _weapp_tailwindcss_shared.cleanUrl)(id), async (id, code, hookContext) => {
+		if (!shouldGenerate || !isCSSRequest(id)) return;
+		await runtimeState.readyPromise;
+		await sourceScanSession.waitForPendingSyncs();
+		const file = (0, _weapp_tailwindcss_shared.cleanUrl)(id);
+		const outputFile = resolveViteCssPipelineOutputFile(file, opts, resolvedConfig?.root ?? node_process.default.cwd(), true, false, void 0);
+		const runtime = hookContext?.sourceCandidates ? new Set(hookContext.sourceCandidates) : await ensureRuntimeClassSet();
+		const generated = await require_v4_generation_core.generateTailwindV4Css({
+			opts,
+			runtimeState,
+			runtime,
+			compilerMode: "legacy",
+			rawSource: require_generator.normalizeEmptyTailwindCustomVariants(code),
+			file,
+			outputFile,
+			cssHandlerOptions: cssHandlerOptions.getCssHandlerOptions(file),
+			cssUserHandlerOptions: cssHandlerOptions.getCssUserHandlerOptions(file),
+			getSourceCandidatesForEntries: (entries) => sourceCandidateCollector.valuesForEntries(entries),
+			generatorPlatform: "web",
+			styleHandler: opts.styleHandler,
+			debug,
+			cssStage: hookContext?.cssStage
+		});
+		if (!generated) return;
+		const tracedCss = require_v4_generation_core.annotateCssSourceTrace(generated.css, {
+			opts,
+			tokenSources: require_v4_generation_core.isCssSourceTraceEnabled(opts) ? require_v4_generation_core.createCssTokenSourceMap(sourceCandidateCollector.sourcesForEntries(void 0), opts) : void 0
+		});
+		generatedCssByFile.set(file, tracedCss);
+		processedCssRegistry.record(file, tracedCss, {
+			injectIntoMain: opts.mainCssChunkMatcher(outputFile, void 0),
+			outputFile
+		});
+		processedCssRegistry.markSource(file);
+		recordedCandidates = new Set(runtime);
+		for (const dependency of generated.dependencies) hookContext?.addWatchFile?.(dependency);
+		return `${require_v4_generation_core.createBundlerGeneratedCssMarker("vite", file)}\n${tracedCss}`;
+	});
+	const rewritePlugins = createRewriteCssImportsPlugins({
+		getAppType: () => void 0,
+		generateTailwindCss: generateCss,
+		rootImport: `${node_path.default.join(require_source_candidate_scan_signature.resolvePackageDir("weapp-tailwindcss"), "generator-placeholder.css").replaceAll(node_path.default.sep, "/")}`,
+		onTailwindRootCss: registerTailwindRootCss,
+		onCssSourceTransform: (id, code) => cssMemory.refreshRememberedCssSourceBySourceFile(id, code),
+		shouldGenerateCss: (_id, code) => hasVitePipelineTailwindGenerationDirective(code),
+		shouldDeferGeneration: () => false,
+		shouldOwnTailwindGeneration: shouldGenerate,
+		shouldRewrite: opts.rewriteCssImports === true,
+		weappTailwindcssDirPosix: node_path.default.dirname(node_path.default.resolve(node_process.default.cwd(), "generator-placeholder.css")).replaceAll(node_path.default.sep, "/")
+	});
+	if (disabled) return rewritePlugins;
+	const sourceCandidatesPlugin = createFrameworkSourceCandidatesPluginForCssOnly({
+		cssMemory,
+		hmrCandidateState,
+		hmrCssModuleVersions,
+		hmrTimingRecorder,
+		invalidateRecordedGeneratorCandidates: () => {
+			recordedCandidates = void 0;
+		},
+		prepareTailwindGeneration: () => sourceScanSession.sync(),
+		refreshRuntimeStateForAutoCssSources: async () => {
+			await refreshRuntimeState(true);
+		},
+		refreshTailwindRootCssSource,
+		rememberTailwindRootCssModule,
+		resolveCurrentGeneratorBranch: () => require_generator.resolveGeneratorRuntimeBranch(resolveWebGeneratorOptions(opts), {
+			appType: void 0,
+			platform: "web",
+			tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+			uniAppX: false
+		}),
+		resolveCurrentGeneratorOptions: () => resolveWebGeneratorOptions(opts),
+		runtimeState,
+		sourceCandidateCollector,
+		sourceScanSession,
+		tailwindRootCssModuleIds,
+		viteProcessedCssSourceFiles: processedCssRegistry.sourceFiles
+	});
+	const postPlugin = createFrameworkPostPlugin({
+		debug,
+		generateBundleHook: void 0,
+		generatorPlaceholderCssFile: node_path.default.join(require_source_candidate_scan_signature.resolvePackageDir("weapp-tailwindcss"), "generator-placeholder.css"),
+		hasExplicitTailwindcssBasedir: false,
+		hasExplicitGeneratorTarget: true,
+		frameworkName: "generic",
+		hmrTimingRecorder,
+		opts,
+		resolveViteStylePlatform: () => "web",
+		refreshRuntimeState: async () => {
+			await refreshRuntimeState(true);
+		},
+		setResolvedConfig: (config) => {
+			resolvedConfig = config;
+		},
+		shouldInferAppType: false,
+		shouldOwnTailwindGeneration: shouldGenerate,
+		syncCssEntriesFromAnchor: () => false
+	});
+	const finalizer = createViteWebCssFinalizerOutputPlugin({
+		opts,
+		runtimeState,
+		ensureRuntimeClassSet,
+		debug,
+		frameworkName: "generic",
+		getResolvedConfig: () => resolvedConfig,
+		markCssAssetProcessed: (asset) => {
+			processedCssAssets.add(asset);
+		},
+		isCssAssetProcessed: (asset) => processedCssAssets.has(asset),
+		isViteProcessedCssAsset: () => true,
+		resolveCssAssetIdentity: createViteCssAssetIdentityResolver({
+			generatorPlaceholderFile: node_path.default.join(require_source_candidate_scan_signature.resolvePackageDir("weapp-tailwindcss"), "generator-placeholder.css"),
+			isKnownProcessedSource: processedCssRegistry.matchesIdentity
+		}),
+		recordCssAssetResult: (file, css) => {
+			generatedCssByFile.set(file, css);
+		},
+		recordViteProcessedCssAssetResult: processedCssRegistry.record,
+		getViteProcessedCssAssetResults: processedCssRegistry.entries,
+		getRecordedGeneratorCandidates: () => recordedCandidates,
+		getSourceCandidates: () => sourceCandidateCollector.values(),
+		getSourceCandidatesForEntries: (entries) => sourceCandidateCollector.valuesForEntries(entries),
+		getSourceCandidateSourcesForEntries: (entries) => sourceCandidateCollector.sourcesForEntries(entries),
+		waitForSourceCandidateSyncs: sourceScanSession.waitForPendingSyncs,
+		hmrTimingRecorder
+	});
+	const plugins = [
+		...rewritePlugins,
+		sourceCandidatesPlugin,
+		...createViteCssGenerationPlugins({
+			generateCss,
+			getCommand: () => resolvedConfig?.command,
+			onTailwindRootCss: registerTailwindRootCss,
+			shouldGenerate: () => shouldGenerate,
+			shouldGenerateBuild: () => true
+		}),
+		postPlugin,
+		finalizer,
+		createViteHmrCssModuleVersionFilterPlugin(hmrCssModuleVersions)
+	];
+	const styleInjectorFactory = options.__internalViteWebStyleInjectorFactory;
+	if (opts.styleInjector !== void 0 && typeof styleInjectorFactory === "function") plugins.push(...styleInjectorFactory(opts.styleInjector));
+	return plugins;
+}
+function createFrameworkSourceCandidatesPluginForCssOnly(options) {
+	return {
+		name: `${require_compiler.vitePluginName}:source-candidates`,
+		enforce: "pre",
+		async transform(code, id) {
+			if (!options.sourceCandidateCollector || !require_v4_generation_core.isSourceCandidateRequest(id)) return;
+			options.cssMemory.rememberKnownSfcSource(id, code);
+			if (isCSSRequest(id) && require_generator.hasUserCssLayerBlocks(code)) options.rememberTailwindRootCssModule(id);
+			await options.sourceCandidateCollector.merge(id, code);
+		},
+		async watchChange(id) {
+			options.invalidateRecordedGeneratorCandidates();
+			options.sourceScanSession.invalidate();
+			await options.sourceScanSession.syncChangedFile(id);
+		},
+		async handleHotUpdate(ctx) {
+			options.invalidateRecordedGeneratorCandidates();
+			await options.sourceScanSession.syncChangedFile(ctx.file, await ctx.read?.());
+			await options.sourceScanSession.waitForPendingSyncs();
+			await options.refreshRuntimeStateForAutoCssSources(true);
+			const root = ctx.server.config?.root ?? node_process.default.cwd();
+			const cssModules = await resolveHotTailwindCssModules(ctx, options.tailwindRootCssModuleIds, (modules) => options.hmrCssModuleVersions.filterModules(modules, ctx.timestamp, root));
+			return cssModules.length > 0 ? mergeHotModulesByIdentity(root, ctx.modules, cssModules) : void 0;
+		}
+	};
+}
+//#endregion
+//#region src/bundlers/vite/frameworks/generic/web.ts
+/** Generic Web CSS-only profile，供 `vite/web` 入口直接使用。 */
+function createGenericWebVitePlugins(options = {}) {
+	const capability = createGenericWebViteCapabilityProfile(options);
+	const owner = createViteSourceOutputRelationOwner();
+	const plugins = withViteSourceOutputRelationOwner(owner, () => createCssOnlyVitePlugins({
+		...options,
+		__internalViteCapabilityProfile: capability,
+		__internalViteWebStyleInjectorFactory: createBuiltinViteWebStyleInjectorPlugins
+	}));
+	if (!plugins) {
+		owner.dispose();
+		return;
+	}
+	return plugins.map((plugin) => {
+		const wrapped = { ...plugin };
+		if (plugin.watchChange) {
+			const hook = plugin.watchChange;
+			wrapped.watchChange = async function(...args) {
+				const id = args[0];
+				if (args[1]?.event === "delete") owner.removeSource(id);
+				else if (typeof id === "string") owner.observeSource(id);
+				return typeof hook === "function" ? hook.apply(this, args) : hook.handler?.apply(this, args);
+			};
+		}
+		if (plugin.handleHotUpdate) {
+			const hook = plugin.handleHotUpdate;
+			wrapped.handleHotUpdate = async function(...args) {
+				const file = args[0]?.file;
+				if (typeof file === "string") owner.observeSource(file);
+				return typeof hook === "function" ? hook.apply(this, args) : hook.handler?.apply(this, args);
+			};
+		}
+		if (plugin.closeBundle) {
+			const hook = plugin.closeBundle;
+			wrapped.closeBundle = async function(...args) {
+				try {
+					return typeof hook === "function" ? await hook.apply(this, args) : await hook.handler?.apply(this, args);
+				} finally {
+					owner.dispose();
+				}
+			};
+		}
+		return wrapped;
+	});
+}
+//#endregion
+Object.defineProperty(exports, "CSS_SOURCE_OUTPUT_EXT_RE", {
+	enumerable: true,
+	get: function() {
+		return CSS_SOURCE_OUTPUT_EXT_RE;
+	}
+});
+Object.defineProperty(exports, "SOURCE_STYLE_OUTPUT_EXT_RE", {
+	enumerable: true,
+	get: function() {
+		return SOURCE_STYLE_OUTPUT_EXT_RE;
+	}
+});
+Object.defineProperty(exports, "appendCss", {
+	enumerable: true,
+	get: function() {
+		return appendCss;
+	}
+});
+Object.defineProperty(exports, "canProcessViteSourceStyleAsCss", {
+	enumerable: true,
+	get: function() {
+		return canProcessViteSourceStyleAsCss;
+	}
+});
+Object.defineProperty(exports, "clearAssetSource", {
+	enumerable: true,
+	get: function() {
+		return clearAssetSource;
+	}
+});
+Object.defineProperty(exports, "collectChunkModuleIds", {
+	enumerable: true,
+	get: function() {
+		return collectChunkModuleIds;
+	}
+});
+Object.defineProperty(exports, "collectImportedStyleFiles", {
+	enumerable: true,
+	get: function() {
+		return collectImportedStyleFiles;
+	}
+});
+Object.defineProperty(exports, "collectMatchingGeneratedCssMarkerFiles", {
+	enumerable: true,
+	get: function() {
+		return collectMatchingGeneratedCssMarkerFiles;
+	}
+});
+Object.defineProperty(exports, "collectRootStyleBundleCssSources", {
+	enumerable: true,
+	get: function() {
+		return collectRootStyleBundleCssSources;
+	}
+});
+Object.defineProperty(exports, "collectViteProcessedCssSources", {
+	enumerable: true,
+	get: function() {
+		return collectViteProcessedCssSources;
+	}
+});
+Object.defineProperty(exports, "createCssAssetPipelineContext", {
+	enumerable: true,
+	get: function() {
+		return createCssAssetPipelineContext;
+	}
+});
+Object.defineProperty(exports, "createCssHandlerOptions", {
+	enumerable: true,
+	get: function() {
+		return createCssHandlerOptions;
+	}
+});
+Object.defineProperty(exports, "createCssHandlerOptionsCache", {
+	enumerable: true,
+	get: function() {
+		return createCssHandlerOptionsCache;
+	}
+});
+Object.defineProperty(exports, "createFrameworkCssGenerationQueue", {
+	enumerable: true,
+	get: function() {
+		return createFrameworkCssGenerationQueue;
+	}
+});
+Object.defineProperty(exports, "createFrameworkPostPlugin", {
+	enumerable: true,
+	get: function() {
+		return createFrameworkPostPlugin;
+	}
+});
+Object.defineProperty(exports, "createFrameworkProcessedCssRegistry", {
+	enumerable: true,
+	get: function() {
+		return createFrameworkProcessedCssRegistry;
+	}
+});
+Object.defineProperty(exports, "createFrameworkSourceScanSession", {
+	enumerable: true,
+	get: function() {
+		return createFrameworkSourceScanSession;
+	}
+});
+Object.defineProperty(exports, "createFrameworkTailwindRootCss", {
+	enumerable: true,
+	get: function() {
+		return createFrameworkTailwindRootCss;
+	}
+});
+Object.defineProperty(exports, "createGenericWebProductionBundleHooks", {
+	enumerable: true,
+	get: function() {
+		return createGenericWebProductionBundleHooks;
+	}
+});
+Object.defineProperty(exports, "createGenericWebProductionSourceCandidatesApply", {
+	enumerable: true,
+	get: function() {
+		return createGenericWebProductionSourceCandidatesApply;
+	}
+});
+Object.defineProperty(exports, "createGenericWebViteCapabilityProfile", {
+	enumerable: true,
+	get: function() {
+		return createGenericWebViteCapabilityProfile;
+	}
+});
+Object.defineProperty(exports, "createGenericWebVitePlugins", {
+	enumerable: true,
+	get: function() {
+		return createGenericWebVitePlugins;
+	}
+});
+Object.defineProperty(exports, "createRewriteCssImportsPlugins", {
+	enumerable: true,
+	get: function() {
+		return createRewriteCssImportsPlugins;
+	}
+});
+Object.defineProperty(exports, "createViteCssAssetIdentityResolver", {
+	enumerable: true,
+	get: function() {
+		return createViteCssAssetIdentityResolver;
+	}
+});
+Object.defineProperty(exports, "createViteCssGenerationPlugins", {
+	enumerable: true,
+	get: function() {
+		return createViteCssGenerationPlugins;
+	}
+});
+Object.defineProperty(exports, "createViteCssMemory", {
+	enumerable: true,
+	get: function() {
+		return createViteCssMemory;
+	}
+});
+Object.defineProperty(exports, "createViteHmrCandidateState", {
+	enumerable: true,
+	get: function() {
+		return createViteHmrCandidateState;
+	}
+});
+Object.defineProperty(exports, "createViteHmrCssModuleVersionFilterPlugin", {
+	enumerable: true,
+	get: function() {
+		return createViteHmrCssModuleVersionFilterPlugin;
+	}
+});
+Object.defineProperty(exports, "createViteHmrCssModuleVersionTracker", {
+	enumerable: true,
+	get: function() {
+		return createViteHmrCssModuleVersionTracker;
+	}
+});
+Object.defineProperty(exports, "createViteRuntimeClassSet", {
+	enumerable: true,
+	get: function() {
+		return createViteRuntimeClassSet;
+	}
+});
+Object.defineProperty(exports, "createViteSourceOutputRelationOwner", {
+	enumerable: true,
+	get: function() {
+		return createViteSourceOutputRelationOwner;
+	}
+});
+Object.defineProperty(exports, "createViteWebCssFinalizerOutputPlugin", {
+	enumerable: true,
+	get: function() {
+		return createViteWebCssFinalizerOutputPlugin;
+	}
+});
+Object.defineProperty(exports, "dedupeViteCssResults", {
+	enumerable: true,
+	get: function() {
+		return dedupeViteCssResults;
+	}
+});
+Object.defineProperty(exports, "extractSfcStyleBlocks", {
+	enumerable: true,
+	get: function() {
+		return extractSfcStyleBlocks;
+	}
+});
+Object.defineProperty(exports, "finalizeWebCss", {
+	enumerable: true,
+	get: function() {
+		return finalizeWebCss;
+	}
+});
+Object.defineProperty(exports, "formatPostcssSourceMap", {
+	enumerable: true,
+	get: function() {
+		return formatPostcssSourceMap;
+	}
+});
+Object.defineProperty(exports, "frameworkViteCapabilityProfile", {
+	enumerable: true,
+	get: function() {
+		return frameworkViteCapabilityProfile;
+	}
+});
+Object.defineProperty(exports, "getActiveViteSourceOutputRelationOwner", {
+	enumerable: true,
+	get: function() {
+		return getActiveViteSourceOutputRelationOwner;
+	}
+});
+Object.defineProperty(exports, "getAssetFile", {
+	enumerable: true,
+	get: function() {
+		return getAssetFile;
+	}
+});
+Object.defineProperty(exports, "hasMatchingStyleFileBase", {
+	enumerable: true,
+	get: function() {
+		return hasMatchingStyleFileBase;
+	}
+});
+Object.defineProperty(exports, "hasNonCommentCss", {
+	enumerable: true,
+	get: function() {
+		return hasNonCommentCss;
+	}
+});
+Object.defineProperty(exports, "hasSelfAcceptingNonStyleHotModule", {
+	enumerable: true,
+	get: function() {
+		return hasSelfAcceptingNonStyleHotModule;
+	}
+});
+Object.defineProperty(exports, "hasSfcStyleSources", {
+	enumerable: true,
+	get: function() {
+		return hasSfcStyleSources;
+	}
+});
+Object.defineProperty(exports, "hasTailwindGenerationSource", {
+	enumerable: true,
+	get: function() {
+		return hasTailwindGenerationSource;
+	}
+});
+Object.defineProperty(exports, "hasVitePipelineTailwindGenerationDirective", {
+	enumerable: true,
+	get: function() {
+		return hasVitePipelineTailwindGenerationDirective;
+	}
+});
+Object.defineProperty(exports, "inferPlatformFromViteOutDir", {
+	enumerable: true,
+	get: function() {
+		return inferPlatformFromViteOutDir;
+	}
+});
+Object.defineProperty(exports, "isCSSRequest", {
+	enumerable: true,
+	get: function() {
+		return isCSSRequest;
+	}
+});
+Object.defineProperty(exports, "isCssOutputFile", {
+	enumerable: true,
+	get: function() {
+		return isCssOutputFile;
+	}
+});
+Object.defineProperty(exports, "isHTMLRequest", {
+	enumerable: true,
+	get: function() {
+		return isHTMLRequest;
+	}
+});
+Object.defineProperty(exports, "isMatchingCssSourceFile", {
+	enumerable: true,
+	get: function() {
+		return isMatchingCssSourceFile;
+	}
+});
+Object.defineProperty(exports, "isMatchingGeneratedCssMarkerFile", {
+	enumerable: true,
+	get: function() {
+		return isMatchingGeneratedCssMarkerFile;
+	}
+});
+Object.defineProperty(exports, "isMiniProgramStyleOutputFile", {
+	enumerable: true,
+	get: function() {
+		return isMiniProgramStyleOutputFile;
+	}
+});
+Object.defineProperty(exports, "isMissingInternalCssSource", {
+	enumerable: true,
+	get: function() {
+		return isMissingInternalCssSource;
+	}
+});
+Object.defineProperty(exports, "isRootStyleOutputFile", {
+	enumerable: true,
+	get: function() {
+		return isRootStyleOutputFile;
+	}
+});
+Object.defineProperty(exports, "isSfcStyleSourceFile", {
+	enumerable: true,
+	get: function() {
+		return isSfcStyleSourceFile;
+	}
+});
+Object.defineProperty(exports, "isStyleImportRequest", {
+	enumerable: true,
+	get: function() {
+		return isStyleImportRequest;
+	}
+});
+Object.defineProperty(exports, "mergeHotModulesByIdentity", {
+	enumerable: true,
+	get: function() {
+		return mergeHotModulesByIdentity;
+	}
+});
+Object.defineProperty(exports, "normalizeCssSourceForCompare", {
+	enumerable: true,
+	get: function() {
+		return normalizeCssSourceForCompare;
+	}
+});
+Object.defineProperty(exports, "normalizeInjectableCssForTarget", {
+	enumerable: true,
+	get: function() {
+		return normalizeInjectableCssForTarget;
+	}
+});
+Object.defineProperty(exports, "normalizeInjectableCssForTargetWithImports", {
+	enumerable: true,
+	get: function() {
+		return normalizeInjectableCssForTargetWithImports;
+	}
+});
+Object.defineProperty(exports, "normalizeMarkerOutputFile", {
+	enumerable: true,
+	get: function() {
+		return normalizeMarkerOutputFile;
+	}
+});
+Object.defineProperty(exports, "normalizePath", {
+	enumerable: true,
+	get: function() {
+		return normalizePath;
+	}
+});
+Object.defineProperty(exports, "normalizeSfcSourceFileForCompare", {
+	enumerable: true,
+	get: function() {
+		return normalizeSfcSourceFileForCompare;
+	}
+});
+Object.defineProperty(exports, "normalizeVitePersistentCacheKey", {
+	enumerable: true,
+	get: function() {
+		return normalizeVitePersistentCacheKey;
+	}
+});
+Object.defineProperty(exports, "parseVueRequest", {
+	enumerable: true,
+	get: function() {
+		return parseVueRequest;
+	}
+});
+Object.defineProperty(exports, "posix", {
+	enumerable: true,
+	get: function() {
+		return posix;
+	}
+});
+Object.defineProperty(exports, "readAssetSource", {
+	enumerable: true,
+	get: function() {
+		return readAssetSource$1;
+	}
+});
+Object.defineProperty(exports, "registerGeneratorDependencies", {
+	enumerable: true,
+	get: function() {
+		return registerGeneratorDependencies;
+	}
+});
+Object.defineProperty(exports, "removeDuplicateUnlinkedRootCssAssetsReferencedByHtml", {
+	enumerable: true,
+	get: function() {
+		return removeDuplicateUnlinkedRootCssAssetsReferencedByHtml;
+	}
+});
+Object.defineProperty(exports, "removeTailwindEntryDirectivesFromCss", {
+	enumerable: true,
+	get: function() {
+		return removeTailwindEntryDirectivesFromCss;
+	}
+});
+Object.defineProperty(exports, "resolveHotSourceModules", {
+	enumerable: true,
+	get: function() {
+		return resolveHotSourceModules;
+	}
+});
+Object.defineProperty(exports, "resolveHotSourceModulesByIds", {
+	enumerable: true,
+	get: function() {
+		return resolveHotSourceModulesByIds;
+	}
+});
+Object.defineProperty(exports, "resolveHotTailwindCssModules", {
+	enumerable: true,
+	get: function() {
+		return resolveHotTailwindCssModules;
+	}
+});
+Object.defineProperty(exports, "resolveMiniProgramStyleOutputExtension", {
+	enumerable: true,
+	get: function() {
+		return resolveMiniProgramStyleOutputExtension;
+	}
+});
+Object.defineProperty(exports, "resolveReplayCssOutputFile", {
+	enumerable: true,
+	get: function() {
+		return resolveReplayCssOutputFile;
+	}
+});
+Object.defineProperty(exports, "resolveSfcStyleRequestFromKnownSource", {
+	enumerable: true,
+	get: function() {
+		return resolveSfcStyleRequestFromKnownSource;
+	}
+});
+Object.defineProperty(exports, "resolveSfcStyleSourceFromOutputFile", {
+	enumerable: true,
+	get: function() {
+		return resolveSfcStyleSourceFromOutputFile;
+	}
+});
+Object.defineProperty(exports, "resolveSourceStyleSourceFromOutputFile", {
+	enumerable: true,
+	get: function() {
+		return resolveSourceStyleSourceFromOutputFile;
+	}
+});
+Object.defineProperty(exports, "resolveViteCssHandlerExtraOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveViteCssHandlerExtraOptions;
+	}
+});
+Object.defineProperty(exports, "resolveViteCssOutputFile", {
+	enumerable: true,
+	get: function() {
+		return resolveViteCssOutputFile;
+	}
+});
+Object.defineProperty(exports, "resolveViteCssPipelineOutputFile", {
+	enumerable: true,
+	get: function() {
+		return resolveViteCssPipelineOutputFile;
+	}
+});
+Object.defineProperty(exports, "resolveViteCssPipelineOutputFileFromSourceFile", {
+	enumerable: true,
+	get: function() {
+		return resolveViteCssPipelineOutputFileFromSourceFile;
+	}
+});
+Object.defineProperty(exports, "resolveViteCssPipelineRequestFile", {
+	enumerable: true,
+	get: function() {
+		return resolveViteCssPipelineRequestFile;
+	}
+});
+Object.defineProperty(exports, "resolveViteModuleIdentity", {
+	enumerable: true,
+	get: function() {
+		return resolveViteModuleIdentity;
+	}
+});
+Object.defineProperty(exports, "resolveViteProcessedCssAssetSource", {
+	enumerable: true,
+	get: function() {
+		return resolveViteProcessedCssAssetSource;
+	}
+});
+Object.defineProperty(exports, "resolveViteWebCssCompatOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveViteWebCssCompatOptions;
+	}
+});
+Object.defineProperty(exports, "sendFullReloadForUnresolvedHotUpdate", {
+	enumerable: true,
+	get: function() {
+		return sendFullReloadForUnresolvedHotUpdate;
+	}
+});
+Object.defineProperty(exports, "sendSupplementalCssHotUpdates", {
+	enumerable: true,
+	get: function() {
+		return sendSupplementalCssHotUpdates;
+	}
+});
+Object.defineProperty(exports, "shouldApplyViteWebCssCompat", {
+	enumerable: true,
+	get: function() {
+		return shouldApplyViteWebCssCompat;
+	}
+});
+Object.defineProperty(exports, "shouldCollectTransformedSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return shouldCollectTransformedSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "shouldGenerateCssByGenerator", {
+	enumerable: true,
+	get: function() {
+		return shouldGenerateCssByGenerator;
+	}
+});
+Object.defineProperty(exports, "shouldSkipGenericWebProductionSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return shouldSkipGenericWebProductionSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "slash", {
+	enumerable: true,
+	get: function() {
+		return slash;
+	}
+});
+Object.defineProperty(exports, "summarizeStringCache", {
+	enumerable: true,
+	get: function() {
+		return summarizeStringCache;
+	}
+});
+Object.defineProperty(exports, "syncFrameworkSourceCandidatesForHotUpdate", {
+	enumerable: true,
+	get: function() {
+		return syncFrameworkSourceCandidatesForHotUpdate;
+	}
+});
+Object.defineProperty(exports, "touchMapEntry", {
+	enumerable: true,
+	get: function() {
+		return touchMapEntry;
+	}
+});
+Object.defineProperty(exports, "tryFinalizeGenericWebCss", {
+	enumerable: true,
+	get: function() {
+		return tryFinalizeGenericWebCss;
+	}
+});
+Object.defineProperty(exports, "withViteSourceOutputRelationOwner", {
+	enumerable: true,
+	get: function() {
+		return withViteSourceOutputRelationOwner;
+	}
+});