weapp-tailwindcss 5.4.2 → 5.5.1

package/dist/web-Cv7ualrU.js

@@ -0,0 +1,3796 @@
+import { resolveImplicitAppTypeFromViteRoot } from "./framework.js";
+import { $ as hasTailwindRootDirectives, O as resolveTailwindcssOptions, Q as hasTailwindNonRootGenerationDirectives, S as findNearestPackageRoot, W as normalizeEmptyTailwindCustomVariants, X as hasLocalCssImport, Z as hasTailwindApplyDirective, a as resolveGeneratorRuntimeBranch, at as removeTailwindSourceDirectives, b as isTailwindV4CssEntry, dt as hasTailwindGeneratedCssMarkers, et as hasTailwindSourceDirectives, ht as stripGeneratorPlaceholderMarkers, i as normalizeWeappTailwindcssGeneratorOptions, kt as resolveSourceScanPath, q as hasUserCssLayerBlocks, rt as normalizeTailwindSourceForGenerator, tt as normalizeTailwindConfigDirectives, ut as hasTailwindGeneratedCss } from "./generator-DyXTBPmE.js";
+import { a as findTailwindConfig, f as resolveSourceScanEntries, l as getRuntimeClassSetSignature } from "./tailwindcss-BK9S7zuq.js";
+import { B as createSourceCandidateCollector, C as isSourceStyleRequest, D as parseBundlerGeneratedCssMarkerBlocks, H as isSourceCandidateRequest, M as isCssSourceTraceEnabled, N as createRuntimeClassSetManager, O as stripBundlerGeneratedCssMarkers, T as createBundlerGeneratedCssMarker, W as createSourceCandidateEligibilityMatcher, g as captureFrameworkPostcssOptions, j as createCssTokenSourceMap, k as annotateCssSourceTrace, m as scoreTailwindV4CssSourceFileMatch, r as generateTailwindV4Css, t as createHmrTimingRecorder, w as stripRequestQuery, z as finalizeCompilerShadowRun } from "./hmr-timing-DNxQm-bN.js";
+import { C as createTailwindRuntimeReadyPromise, K as createDebug, S as collectRuntimeClassSet, T as refreshTailwindRuntimeState, f as getCompilerContext, g as vitePluginName, i as disposeCompilerOwner, n as createRuntimeAffectingSourceSignature, p as normalizeStyleHandlerMajorVersion, t as createCompilerRuntimeState } from "./compiler-B0YSc0DY.js";
+import { n as resolvePackageDir, o as normalizeStyleInjectorOptions, r as normalizeOutputPathKey, t as createSourceCandidateScanSignature } from "./source-candidate-scan-signature-CsP4BQNa.js";
+import { existsSync, realpathSync } from "node:fs";
+import path from "node:path";
+import process$1 from "node:process";
+import { collectCssImportRequestsRoot, isMiniProgramLocalCssImportRequest, parseTailwindCssDirectiveRequest, postcss, removeTailwindPostcssPlugins, removeTailwindSourceDirectivesRoot, removeUnsupportedMiniProgramCssImportsRoot, resolvePostcssConfig, transformWebCssCompat } from "@weapp-tailwindcss/postcss";
+import { LRUCache } from "lru-cache";
+import { readFile } from "node:fs/promises";
+import { cleanUrl as cleanUrl$1, ensurePosix } from "@weapp-tailwindcss/shared";
+import { logger } from "@weapp-tailwindcss/logger";
+import { fileURLToPath } from "node:url";
+import { weappStyleInjector } from "weapp-style-injector/vite";
+import { AsyncLocalStorage } from "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 AsyncLocalStorage();
+function normalizeSourceFile(sourceFile) {
+	return normalizeOutputPathKey(sourceFile.replace(/[?#].*$/, ""));
+}
+function normalizeOutputFile(outputFile) {
+	return 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 = normalizeOutputPathKey(path.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) => normalizeOutputPathKey(path.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 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 = stripRequestQuery(file);
+		const from = path.isAbsolute(sourceFile) ? sourceFile : outputRoot ? path.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: 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 ensurePosix(p);
+}
+const isWindows = process$1.platform === "win32";
+const cssLangRE = new RegExp(`\\.(?:css|less|sass|scss|styl|stylus|pcss|postcss)(?:$|\\?)`);
+const htmlLangRE = /\.html?(?:$|\?)/;
+function isCSSRequest(request) {
+	return cssLangRE.test(request) || 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) ? cleanUrl$1(request) : request;
+}
+function isHTMLRequest(request) {
+	return htmlLangRE.test(request);
+}
+function normalizePath(id) {
+	return path.posix.normalize(isWindows ? ensurePosix(id) : id);
+}
+async function formatPostcssSourceMap(rawMap, file) {
+	const inputFileDir = path.dirname(file);
+	const sources = rawMap.sources.map((source) => {
+		const cleanSource = cleanUrl$1(decodeURIComponent(source));
+		if (cleanSource[0] === "<" && cleanSource.endsWith(">")) return `\0${cleanSource}`;
+		return normalizePath(path.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 = path.resolve(value);
+	let current = resolved;
+	const pendingSegments = [];
+	while (!existsSync(current)) {
+		const parent = path.dirname(current);
+		if (parent === current) return resolved;
+		pendingSegments.unshift(path.basename(current));
+		current = parent;
+	}
+	try {
+		const realPath = realpathSync.native(current);
+		return pendingSegments.length > 0 ? path.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 = path.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 = normalizeOutputPathKey(stem);
+	const stemSuffix = `/${cleanStem}`;
+	const matchedFiles = /* @__PURE__ */ new Set();
+	for (const file of files ?? []) {
+		const cleanFile = normalizeOutputPathKey(file.replace(/[?#].*$/, ""));
+		if (!cssMatcher?.(cleanFile)) continue;
+		const extension = path.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 = path.isAbsolute(cleanFile) ? path.relative(resolveCssOutputRealPath(rootDir), resolveCssOutputRealPath(cleanFile)) : cleanFile;
+	const normalizedFile = normalizeOutputPathKey(nextFile);
+	if (normalizedFile.length === 0 || normalizedFile === "." || normalizedFile === ".." || normalizedFile.startsWith("../")) return normalizeOutputPathKey(path.basename(cleanFile));
+	return normalizedFile;
+}
+function normalizeViteSourceRoot(rootDir, sourceRoot) {
+	if (typeof sourceRoot !== "string" || sourceRoot.trim().length === 0) return;
+	return normalizeOutputPathKey(path.isAbsolute(sourceRoot) ? path.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 path.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 = path.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 = path.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 {
+		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 = path.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 = 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 = `${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 = stripGeneratorPlaceholderMarkers(css);
+		const root = postcss.parse(source);
+		const removedMediaWrappers = removeTailwindSourceMediaWrappersRoot(root);
+		const removedTailwindDirectives = removeTailwindSourceDirectivesRoot(root);
+		return removedMediaWrappers || removedTailwindDirectives ? root.toString() : source;
+	} catch {
+		return 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 = parseTailwindCssDirectiveRequest(params);
+		return request === void 0 || 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 = postcss.parse(css);
+		const changed = isMiniProgramStyleOutputFile(file) ? 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 normalizeOutputPathKey(cleanRequest.slice(1));
+	const targetDir = posix.posix.dirname(normalizeOutputPathKey(targetFile));
+	return 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(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(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 normalizeOutputPathKey(stripStyleExtension(targetFile)) === normalizeOutputPathKey(stripStyleExtension(normalizeMarkerOutputFile(markerFile, resolveViteProcessedCssOutputFile)));
+}
+function resolveViteProcessedCssAssetSource(file, rawSource, resolveViteProcessedCssOutputFile) {
+	const blocks = parseBundlerGeneratedCssMarkerBlocks(rawSource).filter((block) => block.bundler === "vite");
+	if (blocks.length <= 1) return stripBundlerGeneratedCssMarkers(rawSource);
+	const matchedCss = blocks.filter((block) => isMatchingGeneratedCssMarkerFile(file, block.file, resolveViteProcessedCssOutputFile)).map((block) => block.css);
+	return matchedCss.length > 0 ? matchedCss.join("\n") : stripBundlerGeneratedCssMarkers(rawSource);
+}
+function collectMatchingGeneratedCssMarkerFiles(file, rawSource, resolveViteProcessedCssOutputFile) {
+	return 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 = normalizeOutputPathKey(excludedFile);
+	for (const [bundleFile, output] of Object.entries(bundle)) {
+		if (output.type !== "asset") continue;
+		const file = normalizeOutputPathKey(getAssetFile(bundleFile, output));
+		if (file === excludedFileKey || !isRootStyleOutputFile(file)) continue;
+		const source = 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 normalizeOutputPathKey(cleanRequest.slice(1));
+	const htmlDir = posix.posix.dirname(normalizeOutputPathKey(stripQueryAndHash(htmlFile)));
+	return 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 = 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 = 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 = 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 = path.resolve(value);
+	let current = resolved;
+	const pendingSegments = [];
+	while (!existsSync(current)) {
+		const parent = path.dirname(current);
+		if (parent === current) return resolved;
+		pendingSegments.unshift(path.basename(current));
+		current = parent;
+	}
+	try {
+		const realPath = realpathSync.native(current);
+		return pendingSegments.length > 0 ? path.join(realPath, ...pendingSegments) : realPath;
+	} catch {
+		return resolved;
+	}
+}
+function isMatchingCssSourceFile(outputFile, cssSourceFile, outputRoot) {
+	return stripStyleFileExtension(path.resolve(outputRoot, outputFile)) === stripStyleFileExtension(path.resolve(cssSourceFile));
+}
+function collectStyleFileMatchBases(file, roots) {
+	const normalizedFile = file.replace(/[?#].*$/, "");
+	const bases = /* @__PURE__ */ new Set();
+	const addBase = (candidate) => {
+		const base = slash(stripStyleFileExtension(candidate));
+		if (base.length > 0) bases.add(base);
+	};
+	addBase(normalizedFile);
+	const resolvedRoots = roots.filter((root) => typeof root === "string" && root.length > 0).map((root) => path.resolve(root));
+	if (path.isAbsolute(normalizedFile)) for (const root of resolvedRoots) {
+		const relative = path.relative(resolveStyleMatchingRealPath(root), resolveStyleMatchingRealPath(normalizedFile));
+		if (relative && !relative.startsWith("..") && !path.isAbsolute(relative)) addBase(relative);
+	}
+	else for (const root of resolvedRoots) addBase(path.resolve(root, normalizedFile));
+	return bases;
+}
+function collectParentDirectories(file) {
+	const directories = [];
+	let current = path.dirname(path.resolve(file.replace(/[?#].*$/, "")));
+	while (true) {
+		directories.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return directories;
+}
+function hasMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	return scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) > 0;
+}
+function scoreMatchingStyleFileBase(outputFile, sourceFile, outputRoot, sourceRoot) {
+	const outputBases = collectStyleFileMatchBases(outputFile, [outputRoot]);
+	const sourceBases = collectStyleFileMatchBases(sourceFile, [sourceRoot, ...collectParentDirectories(sourceFile)]);
+	let bestScore = 0;
+	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 hasTailwindNonRootGenerationDirectives(source, { importFallback: true }) || allowRootDirectives && hasTailwindSourceDirectives(source, { importFallback: true }) || allowRootDirectives && hasTailwindRootDirectives(source, { importFallback: true }) || hasTailwindApplyDirective(source);
+}
+function hasTailwindGenerationSourceForFile(file, source) {
+	if (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 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 (!path.isAbsolute(file)) return;
+	return path.resolve(file);
+}
+function resolveSiblingJsChunkFile(outputFile, cssMatcher) {
+	const normalizedOutputFile = outputFile.replace(/[?#].*$/, "");
+	if (cssMatcher?.(normalizedOutputFile)) {
+		const extension = path.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 (!path.isAbsolute(file)) return;
+	return path.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 = normalizeOutputPathKey(siblingJsFile);
+	const siblingChunk = snapshot.entries.find((entry) => entry.type === "js" && entry.output.type === "chunk" && 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 = normalizeOutputPathKey(siblingJsFile);
+	const siblingChunk = snapshot.entries.find((entry) => entry.type === "js" && entry.output.type === "chunk" && 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: 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: 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 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(path.win32.resolve(withoutDriveSlash));
+}
+function normalizeFile(file, root) {
+	if (isWindowsFile(file) || isWindowsFile(root)) return normalizeWindowsFile(isWindowsFile(file) ? file : path.win32.resolve(root, file.replace(/^\//, "")));
+	if (path.isAbsolute(file)) {
+		if (file === root || file.startsWith(`${root}${path.sep}`) || existsSync(file) || existsSync(path.dirname(file))) return slash(path.resolve(file));
+		const rootRelativeFile = path.resolve(root, file.slice(1));
+		return existsSync(rootRelativeFile) || existsSync(path.dirname(rootRelativeFile)) ? slash(rootRelativeFile) : slash(path.resolve(file));
+	}
+	return slash(path.resolve(root, file));
+}
+function resolveRealFile(file) {
+	if (process$1.platform !== "win32" && isWindowsFile(file)) return file;
+	let current = file;
+	const missingSegments = [];
+	try {
+		while (true) try {
+			const resolvedParent = realpathSync.native(current);
+			return slash(path.join(resolvedParent, ...missingSegments));
+		} catch {
+			const parent = path.dirname(current);
+			if (parent === current) return file;
+			missingSegments.unshift(path.basename(current));
+			current = parent;
+		}
+	} catch {
+		return file;
+	}
+}
+function normalizeIdentityKey(file) {
+	return isWindowsFile(file) || process$1.platform === "win32" ? file.toLowerCase() : file;
+}
+/**
+* 将 Vite URL、文件路径和 Windows 的等价路径收敛为同一个模块身份。
+*/
+function resolveViteModuleIdentity(id, root = process$1.cwd()) {
+	const cleanId = decodeFileId(cleanUrl$1(id));
+	const decodedRoot = decodeFileId(cleanUrl$1(root));
+	const normalizedRoot = isWindowsFile(decodedRoot) ? normalizeWindowsFile(decodedRoot) : slash(path.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) ? path.win32 : path.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 = process$1.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 ?? process$1.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 ?? process$1.cwd();
+	const outDir = ctx.server.config?.build?.outDir ? resolveViteModuleIdentity(ctx.server.config.build.outDir, root) : void 0;
+	const isHotSourceStyleModule = (id) => {
+		if (!isSourceStyleRequest(id)) return false;
+		const file = cleanUrl$1(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 ?? process$1.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(`${cleanUrl$1(lookupId)}?import`);
+	}
+	return resolveHotModulesByIds(ctx, sourceIds, (mod) => {
+		const modId = mod.id ?? mod.url;
+		return !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 (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(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 path.isAbsolute(file) || /^[A-Z]:[\\/]/i.test(file) || file.startsWith("\\\\");
+}
+function normalizeAbsoluteFilePath(file) {
+	if (/^[A-Z]:[\\/]/i.test(file) || file.startsWith("\\\\")) return slash(path.win32.resolve(file));
+	return slash(path.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 = cleanUrl$1(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(path.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 !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 ?? process$1.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 (!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 ? path.basename(path.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)) {
+			logger.debug("跳过生成模式依赖监听注册，当前 Rollup 阶段不允许 addWatchFile: %s", dependency);
+			continue;
+		}
+		throw error;
+	}
+}
+function createCssHandlerOptions(opts, majorVersion, file, outputRoot, extraOptions = {}) {
+	const from = path.isAbsolute(file) ? file : outputRoot ? path.resolve(outputRoot, file) : file;
+	return {
+		...extraOptions,
+		cssPreflight: opts.cssPreflight,
+		isMainChunk: opts.mainCssChunkMatcher(file, opts.appType),
+		postcssOptions: { options: { from } },
+		...normalizeStyleHandlerMajorVersion(majorVersion) === void 0 ? {} : { majorVersion: 4 }
+	};
+}
+function shouldGenerateCssByGenerator(opts, majorVersion, file, rawSource, processed) {
+	const generatorOptions = normalizeWeappTailwindcssGeneratorOptions(opts.generator, {
+		appType: opts.appType,
+		platform: opts.cssOptions?.platform ?? opts.platform,
+		tailwindcssMajorVersion: majorVersion,
+		uniAppX: opts.uniAppX
+	});
+	if (!generatorOptions.enabled) return false;
+	if (hasLocalCssImport(rawSource)) return false;
+	if (hasTailwindGeneratedCssMarkers(rawSource)) return true;
+	if (hasTailwindRootDirectives(rawSource, { importFallback: generatorOptions.importFallback })) return true;
+	return processed && 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) => 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(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(normalizeOutputPathKey(identity.sourceFile), output);
+		for (const sourceFile of collectMatchingGeneratedCssMarkerFiles(output.file, output.original, (file) => resolveProcessedCssOutputFile(file, options, bundleFiles))) assetBySourceFile.set(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(normalizeOutputPathKey(file)) ?? (outputFile ? cssAssets.get(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 = hasTailwindGeneratedCss(output.original) || 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(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 disposeCompilerOwner(context.runtimeState);
+		},
+		async closeWatcher() {
+			await disposeCompilerOwner(context.runtimeState);
+		},
+		generateBundle: {
+			order: "post",
+			async handler(_options, bundle) {
+				const resolvedConfig = context.getResolvedConfig();
+				if (resolvedConfig?.command !== "build") return;
+				const rootDir = resolvedConfig.root ? path.resolve(resolvedConfig.root) : process$1.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");
+				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 = normalizeOutputPathKey(filename);
+	if (query.type === "style") return `${normalizedFile}?type=style&index=${query.index ?? 0}`;
+	return normalizeOutputPathKey(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 normalizeOutputPathKey(path.resolve(cleanUrl$1(file)));
+}
+function shouldCollectTransformedSourceCandidates(id) {
+	if (isWeappViteSidecarRequest(id)) return false;
+	if (id.search(/[?#]/) < 0) return true;
+	const file = cleanUrl$1(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 = cleanUrl$1(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 = 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 = cleanUrl$1(stripRequestQuery(sourceFile));
+		if (SFC_COMPONENT_FILE_RE.test(file)) return getKnownSfcSource(file);
+		if (isSourceStyleRequest(file)) return options.getSourceCandidateSource(file);
+	};
+	const resolveCurrentStyleSource = (sourceFile) => {
+		const cached = resolveCachedStyleSource(sourceFile);
+		if (cached != null) return cached;
+		const file = cleanUrl$1(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 = cleanUrl$1(sourceFile);
+		const normalizedSourceFile = normalizeOutputPathKey(file);
+		const matchedRememberedSources = [...rememberedCssSources.values()].filter((remembered) => normalizeOutputPathKey(stripRequestQuery(cleanUrl$1(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 (isSourceStyleRequest(file)) refreshRememberedCssSourceBySourceFile(file, source);
+	};
+	const prune = (pruneOptions) => {
+		const activeFiles = new Set([...pruneOptions.activeFiles].map(normalizeOutputPathKey));
+		for (const [key, remembered] of rememberedCssSources) {
+			const outputKey = normalizeOutputPathKey(remembered.outputFile);
+			const sourceKey = 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(normalizeOutputPathKey(file)),
+		getRememberedCssSourceEntry: (file) => rememberedCssSources.get(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(normalizeOutputPathKey(file), cssRuntimeSignature);
+		},
+		prune
+	};
+}
+//#endregion
+//#region src/bundlers/vite/plugin-cache.ts
+function isMissingInternalCssSource(file, packageDir) {
+	return !existsSync(file) && path.resolve(file).startsWith(`${packageDir}${path.sep}`);
+}
+function normalizeVitePersistentCacheKey(file) {
+	return 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/shared/css-imports.ts
+const tailwindcssImportRE = /^(?:tailwindcss|weapp-tailwindcss)(?:\/.*)?$/;
+const tailwindcssCssImportStatementRE = /(@import\s+(?:url\(\s*)?)(["'])((?:tailwindcss|weapp-tailwindcss)(?:\/[^"']*)?\$?)(\2\s*\)?)/gi;
+function normalizeTailwindcssSpecifier(specifier) {
+	if (specifier === "tailwindcss$" || specifier === "weapp-tailwindcss$") return specifier.slice(0, -1);
+	return specifier;
+}
+function getTailwindcssSubpath(specifier) {
+	if (specifier === "tailwindcss" || specifier === "weapp-tailwindcss") return "index.css";
+	return specifier.replace(/^(?:tailwindcss|weapp-tailwindcss)\//, "");
+}
+function resolveTailwindcssImport(specifier, pkgDir, options) {
+	const normalized = normalizeTailwindcssSpecifier(specifier);
+	if (!tailwindcssImportRE.test(normalized)) return null;
+	if (normalized === "tailwindcss" || normalized === "weapp-tailwindcss") return options?.rootImport ?? (options?.join ?? path.join)(pkgDir, "index.css");
+	return (options?.join ?? path.join)(pkgDir, getTailwindcssSubpath(normalized));
+}
+function rewriteTailwindcssImportsInCode(code, pkgDir, options) {
+	let hasReplacements = false;
+	const rewritten = code.replace(tailwindcssCssImportStatementRE, (full, prefix, quote, specifier, suffix) => {
+		const replacement = resolveTailwindcssImport(specifier, pkgDir, options);
+		if (!replacement) return full;
+		hasReplacements = true;
+		return `${prefix}${quote}${replacement}${suffix}`;
+	});
+	return hasReplacements ? rewritten : void 0;
+}
+//#endregion
+//#region src/bundlers/vite/rewrite-css-imports.ts
+function joinPosixPath(base, subpath) {
+	if (base.endsWith("/")) return `${base}${subpath}`;
+	return `${base}/${subpath}`;
+}
+function isCssLikeImporter(importer) {
+	if (!importer) return false;
+	const normalized = cleanUrl$1(importer);
+	return isSourceStyleRequest(importer) || isCSSRequest(normalized) || normalized.endsWith("/*");
+}
+function stripTailwindConfigDirectives(code) {
+	return code.replace(/^\s*@config\s+(?:"[^"]+"|'[^']+')[^;\n]*;\s*$/gm, "");
+}
+function createRewriteCssImportsPlugins(options) {
+	if (!options.shouldRewrite && !options.shouldOwnTailwindGeneration) return [];
+	const { appType, getAppType, rootImport, shouldOwnTailwindGeneration, weappTailwindcssDirPosix } = options;
+	const resolveAppType = () => getAppType?.() ?? appType;
+	return [{
+		name: `${vitePluginName}:rewrite-css-imports`,
+		enforce: "pre",
+		resolveId(id, importer) {
+			if (!options.shouldRewrite) return null;
+			const replacement = resolveTailwindcssImport(id, weappTailwindcssDirPosix, {
+				join: joinPosixPath,
+				appType: resolveAppType(),
+				rootImport
+			});
+			if (!replacement) return null;
+			if (importer && !isCssLikeImporter(importer)) return null;
+			return replacement;
+		},
+		async transform(code, id) {
+			if (!isCSSRequest(id)) return null;
+			const file = cleanUrl$1(id);
+			const normalizedCode = !isSfcStyleSourceFile(file) && (hasTailwindRootDirectives(code) || code.includes("@config")) ? normalizeTailwindConfigDirectives(code, path.dirname(file)) : code;
+			await options.onCssSourceTransform?.(id, normalizedCode);
+			const hasTailwindRoot = 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 = rewriteTailwindcssImportsInCode(normalizedCode, weappTailwindcssDirPosix, {
+				join: joinPosixPath,
+				appType: resolveAppType(),
+				rootImport
+			});
+			const nextCode = shouldOwnTailwindGeneration ? stripTailwindConfigDirectives(rewritten ?? normalizedCode) : rewritten;
+			if (!nextCode || nextCode === code) return null;
+			return {
+				code: nextCode,
+				map: null
+			};
+		}
+	}];
+}
+function hasVitePipelineTailwindGenerationDirective(code) {
+	return hasTailwindRootDirectives(code) || hasTailwindApplyDirective(code);
+}
+//#endregion
+//#region src/bundlers/vite/runtime-class-set.ts
+function createViteRuntimeClassSet(options) {
+	const { opts, initialTailwindRuntime, refreshTailwindcssRuntime, uniAppXEnabled, customAttributesEntities, disabledDefaultTemplateHandler, debug } = options;
+	const readyPromise = createTailwindRuntimeReadyPromise(initialTailwindRuntime);
+	const runtimeState = createCompilerRuntimeState({
+		tailwindRuntime: initialTailwindRuntime,
+		readyPromise,
+		refreshTailwindcssRuntime
+	});
+	const bundleRuntimeClassSetManager = createRuntimeClassSetManager({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		escapeMap: opts.escapeMap
+	});
+	const transformRuntimeClassSetManager = createRuntimeClassSetManager({
+		bareArbitraryValues: opts.arbitraryValues?.bareArbitraryValues,
+		escapeMap: opts.escapeMap
+	});
+	let runtimeSet;
+	let runtimeSetPromise;
+	let runtimeRefreshSignature;
+	let runtimeRefreshOptionsKey;
+	function resolveRuntimeRefreshOptions() {
+		const configPath = resolveTailwindcssOptions(runtimeState.tailwindRuntime.options)?.config;
+		const signature = 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 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 || process$1.env["WEAPP_TW_VITE_FORCE_RUNTIME_REFRESH"] === "1";
+		await refreshRuntimeState(force);
+		await runtimeState.readyPromise;
+		if (!forceRuntimeRefresh && runtimeSet) return runtimeSet;
+		if (forceRuntimeRefresh || !runtimeSetPromise) {
+			const invalidation = resolveRuntimeRefreshOptions();
+			runtimeSetPromise = collectRuntimeClassSet(runtimeState.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 || process$1.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 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 = 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" && isSourceStyleRequest(id) && !SPECIAL_QUERY_RE.test(id) && !COMMON_JS_PROXY_RE.test(id);
+}
+function isViteServeCssRootRequest(id, command) {
+	return command === "serve" && isSourceStyleRequest(id) && !SPECIAL_QUERY_RE.test(id) && !COMMON_JS_PROXY_RE.test(id);
+}
+function isViteBuildStyleRequest(id, command) {
+	return command === "build" && 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 hasTailwindRootDirectives(code) || hasTailwindSourceDirectives(code, { importFallback: true }) || hasTailwindApplyDirective(code);
+}
+function hasViteServeCssRootDirective(code) {
+	return hasTailwindRootDirectives(code);
+}
+function createViteCssGenerationPlugins(options) {
+	return [
+		{
+			name: `${vitePluginName}:generate:serve`,
+			apply: "serve",
+			enforce: "pre",
+			async transform(code, id) {
+				if (!options.shouldGenerate() || !isViteServeCssRootRequest(id, options.getCommand())) return;
+				if (!hasTailwindRootDirectives(code)) return;
+				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: `${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: `${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(cleanUrl$1(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 || isSourceStyleRequest(file)
+	});
+	const apply = (change) => {
+		if (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" && 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 isSourceStyleRequest(request);
+				});
+				if (styleModules.length === 0) return;
+				const root = ctx.server.config?.root ?? process$1.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 = path.resolve(root);
+	if (!existsSync(resolvedRoot)) return resolvedRoot;
+	const searchRoots = [];
+	let current = resolvedRoot;
+	while (true) {
+		searchRoots.push(current);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	const tailwindConfigPath = findTailwindConfig(searchRoots);
+	if (tailwindConfigPath) return path.dirname(tailwindConfigPath);
+	const packageRoot = findNearestPackageRoot(resolvedRoot);
+	if (packageRoot && existsSync(path.join(packageRoot, PACKAGE_JSON_FILE))) return packageRoot;
+	return resolvedRoot;
+}
+//#endregion
+//#region src/bundlers/vite/shared/framework-post-plugin.ts
+function createFrameworkPostPlugin(options) {
+	const plugin = {
+		name: `${vitePluginName}:post`,
+		enforce: "post",
+		config(config) {
+			if (!options.shouldOwnTailwindGeneration) return;
+			if (Array.isArray(config.plugins)) {
+				const removed = disableAndRemoveTailwindVitePlugins(config.plugins);
+				if (removed > 0) {
+					logger.warn("检测到 @tailwindcss/vite，生成模式下已移除该插件以避免 Tailwind CSS 重复生成。");
+					options.debug("disable official tailwind vite plugins in generator mode: %d", removed);
+				}
+			}
+			const root = config.root ? path.resolve(config.root) : process$1.cwd();
+			const baseConfig = { resolve: { alias: [{
+				find: /^tailwindcss$/,
+				replacement: options.generatorPlaceholderCssFile
+			}] } };
+			if (config.css?.postcss !== void 0) return baseConfig;
+			return resolvePostcssConfig(root).then((postcssConfig) => {
+				if (!postcssConfig) return baseConfig;
+				const plugins = [...postcssConfig.plugins];
+				const removed = 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 ? path.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 = resolveImplicitAppTypeFromViteRoot(resolvedRoot, { searchUp: false });
+					if (nextAppType && options.opts.appType !== nextAppType) {
+						const previousAppType = options.opts.appType;
+						options.opts.appType = nextAppType;
+						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"
+					};
+					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 = removeTailwindPostcssPlugins(postcssPlugins);
+						if (removed > 0) {
+							logger.warn("检测到 @tailwindcss/postcss，生成模式下已移除该插件以避免 Tailwind CSS 重复生成。");
+							options.debug("remove official tailwind postcss plugins in generator mode: %d", removed);
+						}
+					}
+				}
+				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(path.resolve(cleanUrl$1(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(path.resolve(cleanUrl$1(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(cleanUrl$1(file)) ? extractSfcStyleSources(source).filter((styleSource) => WEB_HMR_RUNTIME_AFFECTING_DIRECTIVE_RE.test(styleSource)) : [source]).map((styleSource) => 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 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 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) => path.normalize(path.resolve(cleanUrl$1(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([path.resolve(root)]);
+		const basedir = options.opts.tailwindcssBasedir ? path.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 (!isTailwindV4CssEntry(cssEntry)) continue;
+			const cssEntryRoot = path.dirname(path.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 = createSourceCandidateEligibilityMatcher(matcherRoots);
+		sourceScanMatcher = 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 ?? process$1.cwd();
+		const outDir = resolvedConfig?.build?.outDir;
+		const sourceScan = await 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 = 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 = cleanUrl$1(id);
+		const runtimeAffectingByDependency = isDependency(file);
+		if (runtimeAffectingByDependency) invalidate();
+		const resolvedFile = 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 (isSourceStyleRequest(file) ? 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 = cleanUrl$1(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 = cleanUrl$1(id);
+		const existingTask = pendingSourceCandidateSyncByFile.get(file);
+		if (existingTask) {
+			await existingTask;
+			return syncChangedFile(id, sourceOverride);
+		}
+		return syncChangedFileNow(file, sourceOverride);
+	};
+	return {
+		cacheCurrent,
+		consumeHotUpdateChange: (id) => pendingHotUpdateChangeByFile.delete(cleanUrl$1(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 (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 = cleanUrl$1(id);
+		if (!moduleIds.has(id) && !moduleIds.has(file) && !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 = normalizeStyleInjectorOptions(options);
+	if (!normalized) return [];
+	const injector = 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 = createDebug();
+function resolveWebGeneratorOptions(opts) {
+	return 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 : 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 = 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 = 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: 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, normalizeTailwindSourceForGenerator(normalizeTailwindConfigDirectives(css, path.dirname(cleanUrl$1(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) => cleanUrl$1(id), async (id, code, hookContext) => {
+		if (!shouldGenerate || !isCSSRequest(id)) return;
+		await runtimeState.readyPromise;
+		await sourceScanSession.waitForPendingSyncs();
+		const file = cleanUrl$1(id);
+		const outputFile = resolveViteCssPipelineOutputFile(file, opts, resolvedConfig?.root ?? process$1.cwd(), true, false, void 0);
+		const runtime = hookContext?.sourceCandidates ? new Set(hookContext.sourceCandidates) : await ensureRuntimeClassSet();
+		const generated = await generateTailwindV4Css({
+			opts,
+			runtimeState,
+			runtime,
+			compilerMode: "legacy",
+			rawSource: 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 = annotateCssSourceTrace(generated.css, {
+			opts,
+			tokenSources: isCssSourceTraceEnabled(opts) ? 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 `${createBundlerGeneratedCssMarker("vite", file)}\n${tracedCss}`;
+	});
+	const rewritePlugins = createRewriteCssImportsPlugins({
+		getAppType: () => void 0,
+		generateTailwindCss: generateCss,
+		rootImport: `${path.join(resolvePackageDir("weapp-tailwindcss"), "generator-placeholder.css").replaceAll(path.sep, "/")}`,
+		onTailwindRootCss: registerTailwindRootCss,
+		onCssSourceTransform: (id, code) => cssMemory.refreshRememberedCssSourceBySourceFile(id, code),
+		shouldGenerateCss: (_id, code) => hasVitePipelineTailwindGenerationDirective(code),
+		shouldDeferGeneration: () => false,
+		shouldOwnTailwindGeneration: shouldGenerate,
+		shouldRewrite: opts.rewriteCssImports === true,
+		weappTailwindcssDirPosix: path.dirname(path.resolve(process$1.cwd(), "generator-placeholder.css")).replaceAll(path.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: () => 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: path.join(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: path.join(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: `${vitePluginName}:source-candidates`,
+		enforce: "pre",
+		async transform(code, id) {
+			if (!options.sourceCandidateCollector || !isSourceCandidateRequest(id)) return;
+			options.cssMemory.rememberKnownSfcSource(id, code);
+			if (isCSSRequest(id) && 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 ?? process$1.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
+export { isMatchingCssSourceFile as $, createGenericWebProductionSourceCandidatesApply as A, resolveViteCssPipelineOutputFileFromSourceFile as At, parseVueRequest as B, createViteCssAssetIdentityResolver as Bt, collectViteProcessedCssSources as C, SOURCE_STYLE_OUTPUT_EXT_RE as Ct, registerGeneratorDependencies as D, resolveReplayCssOutputFile as Dt, inferPlatformFromViteOutDir as E, resolveMiniProgramStyleOutputExtension as Et, resolveHotSourceModulesByIds as F, normalizePath as Ft, hasSfcStyleSources as G, frameworkViteCapabilityProfile as Gt, shouldApplyViteWebCssCompat as H, getActiveViteSourceOutputRelationOwner as Ht, resolveHotTailwindCssModules as I, resolveViteCssPipelineRequestFile as It, normalizeSfcSourceFileForCompare as J, hasTailwindGenerationSource as K, sendFullReloadForUnresolvedHotUpdate as L, slash as Lt, hasSelfAcceptingNonStyleHotModule as M, formatPostcssSourceMap as Mt, mergeHotModulesByIdentity as N, isCSSRequest as Nt, shouldGenerateCssByGenerator as O, resolveViteCssOutputFile as Ot, resolveHotSourceModules as P, isHTMLRequest as Pt, hasMatchingStyleFileBase as Q, sendSupplementalCssHotUpdates as R, createCssHandlerOptionsCache as Rt, tryFinalizeGenericWebCss as S, CSS_SOURCE_OUTPUT_EXT_RE as St, finalizeWebCss as T, normalizeCssSourceForCompare as Tt, collectChunkModuleIds as U, withViteSourceOutputRelationOwner as Ut, resolveViteWebCssCompatOptions as V, createViteSourceOutputRelationOwner as Vt, extractSfcStyleBlocks as W, createGenericWebViteCapabilityProfile as Wt, resolveSfcStyleSourceFromOutputFile as X, resolveSfcStyleRequestFromKnownSource as Y, resolveSourceStyleSourceFromOutputFile as Z, summarizeStringCache as _, resolveViteProcessedCssAssetSource as _t, createFrameworkProcessedCssRegistry as a, createCssAssetPipelineContext as at, touchMapEntry as b, isRootStyleOutputFile as bt, createViteHmrCssModuleVersionTracker as c, hasNonCommentCss as ct, createViteCssGenerationPlugins as d, normalizeInjectableCssForTarget as dt, appendCss as et, createViteRuntimeClassSet as f, normalizeInjectableCssForTargetWithImports as ft, normalizeVitePersistentCacheKey as g, removeTailwindEntryDirectivesFromCss as gt, isMissingInternalCssSource as h, removeDuplicateUnlinkedRootCssAssetsReferencedByHtml as ht, syncFrameworkSourceCandidatesForHotUpdate as i, collectRootStyleBundleCssSources as it, shouldSkipGenericWebProductionSourceCandidates as j, cleanUrl$1 as jt, createGenericWebProductionBundleHooks as k, resolveViteCssPipelineOutputFile as kt, createViteHmrCandidateState as l, isMatchingGeneratedCssMarkerFile as lt, hasVitePipelineTailwindGenerationDirective as m, readAssetSource$1 as mt, createFrameworkTailwindRootCss as n, collectImportedStyleFiles as nt, createFrameworkPostPlugin as o, dedupeViteCssResults as ot, createRewriteCssImportsPlugins as p, normalizeMarkerOutputFile as pt, isSfcStyleSourceFile as q, createFrameworkSourceScanSession as r, collectMatchingGeneratedCssMarkerFiles as rt, createViteHmrCssModuleVersionFilterPlugin as s, getAssetFile as st, createGenericWebVitePlugins as t, clearAssetSource as tt, createFrameworkCssGenerationQueue as u, isStyleImportRequest as ut, createViteCssMemory as v, isCssOutputFile as vt, createCssHandlerOptions as w, canProcessViteSourceStyleAsCss as wt, createViteWebCssFinalizerOutputPlugin as x, posix as xt, shouldCollectTransformedSourceCandidates as y, isMiniProgramStyleOutputFile as yt, resolveViteModuleIdentity as z, resolveViteCssHandlerExtraOptions as zt };