weapp-tailwindcss 5.0.13 → 5.1.1

package/dist/webpack-8PaV1gG3.mjs

@@ -0,0 +1,2334 @@
+import { C as hasTailwindRootDirectives, F as hasTailwindGeneratedCssMarkers, G as getTailwindV4IncrementalGenerateCacheStats, O as parseImportRequest, P as hasTailwindGeneratedCss, T as normalizeTailwindConfigDirectives, _ as resolveTailwindcssOptions, ct as inferGeneratorTargetFromEnv, k as removeTailwindSourceDirectives, nt as resolveSourceScanPath, o as hasConfiguredTailwindV4CssRoots, s as upsertTailwindV4CssSource, w as hasTailwindSourceDirectives, x as hasTailwindApplyDirective } from "./v4-engine-C3qSwQ-e.mjs";
+import { o as resolveRuntimeBranch } from "./generator-CjzBK7h-.mjs";
+import { r as getGroupedEntries } from "./utils-DodxWHGz.mjs";
+import { C as md5Hash, S as createDebug, b as ensureRuntimeClassSet, f as _defineProperty, i as pluginName, l as shouldSkipJsTransform, n as normalizeStyleHandlerMajorVersion, r as resolveStyleOptionsFromContext, t as getCompilerContext, x as refreshTailwindRuntimeState, y as createTailwindRuntimeReadyPromise } from "./context-DlpKD7aN.mjs";
+import { l as getRuntimeClassSetSignature, p as resolveViteSourceScanEntries } from "./tailwindcss-B5mRo0-M.mjs";
+import { C as stripTailwindSourceMediaFragments, D as createCssSourceOrderAppend, E as removeGeneratedSelectorCompatCss, F as createCssTokenSourceMap, I as isCssSourceTraceEnabled, L as processCachedTask, M as stripMiniProgramCssSpecificityPlaceholders, N as annotateCssSourceTrace, O as hasMiniProgramTailwindV4PreflightReset, P as createCssSourceTraceCacheSignature, S as removeTailwindV4GeneratorAtRules, T as scoreTailwindV4CssSourceFileMatch, _ as isPureLocalCssImportWrapper, a as isSourceCandidateRequest, b as removeMiniProgramHoverSelectors, c as collectStrictEscapedRuntimeCandidates, f as pushConcurrentTaskFactories, i as createSourceCandidateStore, j as pruneMiniProgramGeneratedCss, k as finalizeMiniProgramCss, l as createEscapeFragments, n as emitHmrTiming, o as resolveSourceCandidateScanFiles, p as resolveTaskConcurrency, s as createBundleRuntimeClassSetManager, w as stripUnmatchedTailwindSourceMediaCloseFragments, x as removeTailwindV4GeneratedUserCssArtifacts } from "./hmr-timing-B0KuWDjV.mjs";
+import { A as isSourceStyleRequest, C as resolvePluginDisabledState, N as resolveOutputSpecifier, P as toAbsoluteOutputPath, S as resolvePackageDir, _ as generateTailwindV4Css, d as classifyBundleEntry, f as createBundleBuildState, i as createCandidateSignature, j as stripRequestQuery, m as createRuntimeAffectingSourceSignature, p as updateBundleBuildState, r as createScopedGeneratorRuntime, t as createSourceCandidateScanSignature, x as stripBundlerGeneratedCssMarkers, y as hasBundlerGeneratedCssMarker } from "./source-candidate-scan-signature-B5af2Ahe.mjs";
+import Module, { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { filterExistingCssRules, postcss } from "@weapp-tailwindcss/postcss";
+import { readFile, stat } from "node:fs/promises";
+import micromatch from "micromatch";
+import { MappingChars2String } from "@weapp-core/escape";
+import { fileURLToPath } from "node:url";
+//#region src/shared/tailwindcss-css-redirect.ts
+const moduleWithMutableResolve = Module;
+const patched = /* @__PURE__ */ new WeakSet();
+function installTailwindcssCssRedirect(pkgDir) {
+	const target = path.join(pkgDir, "index.css");
+	const original = moduleWithMutableResolve._resolveFilename;
+	if (patched.has(original)) return;
+	const replacements = new Set(["tailwindcss", "tailwindcss$"]);
+	const resolveTailwindcssCss = (request, parent, isMain, options) => {
+		if (replacements.has(request)) return target;
+		if (request.startsWith("tailwindcss/")) return path.join(pkgDir, request.slice(12));
+		return original(request, parent, isMain, options);
+	};
+	moduleWithMutableResolve._resolveFilename = resolveTailwindcssCss;
+	patched.add(moduleWithMutableResolve._resolveFilename);
+}
+//#endregion
+//#region src/shared/mpx.ts
+const localRequire = createRequire(import.meta.url);
+const MPX_STYLE_RESOURCE_QUERY_RE$1 = /(?:^|[?&])type=styles(?:&|$)/;
+const MPX_WEBPACK_PLUGIN_PACKAGE_RE = /@mpxjs[\\/]webpack-plugin[\\/]package\.json$/;
+function isMpxStyleResourceQuery(query) {
+	if (typeof query !== "string") return false;
+	return MPX_STYLE_RESOURCE_QUERY_RE$1.test(query);
+}
+function isMpx(appType) {
+	return appType === "mpx";
+}
+function getTailwindcssCssEntry(pkgDir) {
+	return path.join(pkgDir, "index.css");
+}
+function resolveMpxWebpackPluginDir(compiler) {
+	const candidates = [
+		compiler?.context,
+		compiler?.options?.context,
+		process.cwd()
+	].filter((item) => typeof item === "string" && item.length > 0);
+	for (const candidate of candidates) try {
+		const projectRequire = createRequire(path.join(candidate, "package.json"));
+		return path.dirname(projectRequire.resolve("@mpxjs/webpack-plugin/package.json"));
+	} catch {}
+	const cachedPackageJson = Object.keys(localRequire.cache).find((file) => MPX_WEBPACK_PLUGIN_PACKAGE_RE.test(file));
+	if (cachedPackageJson) return path.dirname(cachedPackageJson);
+	try {
+		return path.dirname(localRequire.resolve("@mpxjs/webpack-plugin/package.json"));
+	} catch {
+		return;
+	}
+}
+function isMpxWebpackPluginRequest(request) {
+	return request === "@mpxjs/webpack-plugin" || Boolean(request?.startsWith("@mpxjs/webpack-plugin/"));
+}
+function resolveMpxWebpackPluginRequest(request, mpxWebpackPluginDir) {
+	if (request === "@mpxjs/webpack-plugin") return mpxWebpackPluginDir;
+	return path.join(mpxWebpackPluginDir, request.slice(22));
+}
+function addMpxWebpackPluginAlias(alias, pkgDir) {
+	const recordLoader = path.join(pkgDir, "lib/record-loader");
+	const styleCompiler = path.join(pkgDir, "lib/style-compiler/index");
+	const stripConditionalLoader = path.join(pkgDir, "lib/style-compiler/strip-conditional-loader");
+	if (Array.isArray(alias)) alias.push({
+		name: "@mpxjs/webpack-plugin/lib/record-loader",
+		alias: recordLoader
+	}, {
+		name: "@mpxjs/webpack-plugin/lib/style-compiler/index",
+		alias: styleCompiler
+	}, {
+		name: "@mpxjs/webpack-plugin/lib/style-compiler/strip-conditional-loader",
+		alias: stripConditionalLoader
+	}, {
+		name: /^@mpxjs\/webpack-plugin\//,
+		alias: pkgDir
+	});
+	else {
+		alias["@mpxjs/webpack-plugin"] = pkgDir;
+		alias["@mpxjs/webpack-plugin$"] = pkgDir;
+		alias["@mpxjs/webpack-plugin/lib/record-loader"] = recordLoader;
+		alias["@mpxjs/webpack-plugin/lib/style-compiler/index"] = styleCompiler;
+		alias["@mpxjs/webpack-plugin/lib/style-compiler/strip-conditional-loader"] = stripConditionalLoader;
+	}
+}
+function ensureResolveLoaderAlias(compiler, mpxWebpackPluginDir) {
+	compiler.options.resolveLoader = compiler.options.resolveLoader || {};
+	const alias = compiler.options.resolveLoader.alias ?? {};
+	compiler.options.resolveLoader.alias = alias;
+	addMpxWebpackPluginAlias(alias, mpxWebpackPluginDir);
+}
+function resolveMpxWebpackPluginRequire(compiler) {
+	const candidates = [
+		compiler?.context,
+		compiler?.options?.context,
+		process.cwd()
+	].filter((item) => typeof item === "string" && item.length > 0);
+	for (const candidate of candidates) try {
+		const projectRequire = createRequire(path.join(candidate, "package.json"));
+		projectRequire.resolve("@mpxjs/webpack-plugin/package.json");
+		return projectRequire;
+	} catch {}
+	const cachedPackageJson = Object.keys(localRequire.cache).find((file) => MPX_WEBPACK_PLUGIN_PACKAGE_RE.test(file));
+	if (cachedPackageJson) return createRequire(cachedPackageJson);
+	return localRequire;
+}
+function patchMpxWebpackPluginNormalizeLib(compiler, mpxWebpackPluginDir) {
+	if (!mpxWebpackPluginDir) return false;
+	const projectRequire = resolveMpxWebpackPluginRequire(compiler);
+	let normalize;
+	try {
+		normalize = projectRequire("@mpxjs/webpack-plugin/lib/utils/normalize");
+	} catch {
+		return false;
+	}
+	if (typeof normalize.lib !== "function") return false;
+	if (normalize.lib.__weappTwPatched) return true;
+	const wrappedLib = (file) => path.join(mpxWebpackPluginDir, "lib", file);
+	wrappedLib.__weappTwPatched = true;
+	wrappedLib.__weappTwOriginal = normalize.lib;
+	normalize.lib = wrappedLib;
+	return true;
+}
+function ensureMpxTailwindcssAliases(compiler, pkgDir) {
+	const tailwindcssCssEntry = getTailwindcssCssEntry(pkgDir);
+	compiler.options = compiler.options || {};
+	compiler.options.resolve = compiler.options.resolve || {};
+	const mpxWebpackPluginDir = resolveMpxWebpackPluginDir(compiler);
+	patchMpxWebpackPluginNormalizeLib(compiler, mpxWebpackPluginDir);
+	if (mpxWebpackPluginDir) ensureResolveLoaderAlias(compiler, mpxWebpackPluginDir);
+	const alias = compiler.options.resolve.alias ?? {};
+	compiler.options.resolve.alias = alias;
+	if (Array.isArray(alias)) alias.push({
+		name: "tailwindcss",
+		alias: tailwindcssCssEntry
+	}, {
+		name: "tailwindcss$",
+		alias: tailwindcssCssEntry
+	});
+	else {
+		alias.tailwindcss = tailwindcssCssEntry;
+		alias.tailwindcss$ = tailwindcssCssEntry;
+	}
+	if (mpxWebpackPluginDir) addMpxWebpackPluginAlias(alias, mpxWebpackPluginDir);
+	return tailwindcssCssEntry;
+}
+function patchMpxLoaderResolve(loaderContext, pkgDir, enabled) {
+	if (!enabled || typeof loaderContext.resolve !== "function") return;
+	const originalResolve = loaderContext.resolve;
+	if (originalResolve.__weappTwPatched) return;
+	const tailwindcssCssEntry = getTailwindcssCssEntry(pkgDir);
+	const mpxWebpackPluginDir = resolveMpxWebpackPluginDir(loaderContext);
+	const wrappedResolve = function(context, request, callback) {
+		if (request === "tailwindcss" || request === "tailwindcss$") return callback(null, tailwindcssCssEntry);
+		if (request?.startsWith("tailwindcss/")) return callback(null, path.join(pkgDir, request.slice(12)));
+		if (mpxWebpackPluginDir && isMpxWebpackPluginRequest(request)) return callback(null, resolveMpxWebpackPluginRequest(request, mpxWebpackPluginDir));
+		return originalResolve.call(this, context, request, callback);
+	};
+	wrappedResolve.__weappTwPatched = true;
+	loaderContext.resolve = wrappedResolve;
+}
+function setupMpxTailwindcssRedirect(pkgDir, enabled) {
+	if (enabled) installTailwindcssCssRedirect(pkgDir);
+}
+const CSS_EXT_RE = /\.css$/i;
+function injectMpxCssRewritePreRules(compiler, loader, loaderOptions) {
+	var _compiler$options;
+	if (!loader) return;
+	const moduleOptions = (_compiler$options = compiler.options).module ?? (_compiler$options.module = { rules: [] });
+	moduleOptions.rules = moduleOptions.rules || [];
+	const createRule = (match) => ({
+		...match,
+		enforce: "pre",
+		use: [{
+			loader,
+			options: loaderOptions
+		}]
+	});
+	moduleOptions.rules.unshift(createRule({ resourceQuery: (query) => isMpxStyleResourceQuery(query) }), createRule({
+		test: CSS_EXT_RE,
+		resourceQuery: (query) => !isMpxStyleResourceQuery(query)
+	}));
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/shared.ts
+const MPX_STYLE_RESOURCE_QUERY_RE = /(?:\?|&)type=styles\b/;
+function getCacheKey(filename) {
+	return filename;
+}
+function stripResourceQuery(resource) {
+	if (typeof resource !== "string") return resource;
+	return stripRequestQuery(resource);
+}
+function isCssLikeModuleResource(resource, cssMatcher, appType) {
+	if (typeof resource !== "string") return false;
+	const normalizedResource = stripResourceQuery(resource);
+	if (normalizedResource && cssMatcher(normalizedResource)) return true;
+	if (isSourceStyleRequest(resource)) return true;
+	if (appType === "mpx") return MPX_STYLE_RESOURCE_QUERY_RE.test(resource);
+	return false;
+}
+function hasLoaderEntry(entries, target) {
+	if (!target) return false;
+	return entries.some((entry) => entry.loader?.includes?.(target));
+}
+function normalizeWatchPath(file) {
+	return path.resolve(file);
+}
+function isFileInContext(file, context) {
+	const relative = path.relative(normalizeWatchPath(context), normalizeWatchPath(file));
+	return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function toChunkFiles(files) {
+	if (!files) return [];
+	if (Array.isArray(files)) return files;
+	return [...files];
+}
+function inferWebpackMainCssFiles(chunks, cssMatcher, options = {}) {
+	const mainCssFiles = /* @__PURE__ */ new Set();
+	const shouldCheckSourceResources = Boolean(options.mainSourceFiles?.size);
+	for (const chunk of chunks) {
+		const files = toChunkFiles(chunk.files);
+		if (!(chunk.hasRuntime?.() === true)) continue;
+		for (const file of files) {
+			if (!cssMatcher(file)) continue;
+			if (shouldCheckSourceResources) {
+				const resources = options.resourcesByAsset?.get(file);
+				if (!resources || ![...resources].some((resource) => options.mainSourceFiles?.has(resource))) continue;
+			}
+			mainCssFiles.add(file);
+		}
+	}
+	return mainCssFiles;
+}
+function resolveSingleActiveWebpackCssResource(assetResources, activeWebpackAssetResourceFiles) {
+	const activeAssetResourceMatches = [...assetResources ?? []].map((sourceFile) => path.resolve(sourceFile)).filter((sourceFile) => activeWebpackAssetResourceFiles.has(sourceFile)).sort();
+	return activeAssetResourceMatches.length === 1 ? activeAssetResourceMatches[0] : void 0;
+}
+function createWebpackCssAssetResourceMap(chunks, chunkGraph, cssMatcher, normalizeResource) {
+	const resourcesByAsset = /* @__PURE__ */ new Map();
+	if (!chunkGraph?.getChunkModulesIterable) return resourcesByAsset;
+	const collectModuleResources = (module, resources, seen = /* @__PURE__ */ new Set()) => {
+		if (!module || seen.has(module)) return;
+		seen.add(module);
+		for (const candidate of [
+			module.resource,
+			module.request,
+			module.userRequest
+		]) {
+			if (typeof candidate !== "string") continue;
+			const normalized = normalizeResource(candidate, module);
+			if (normalized) resources.add(normalized);
+		}
+		for (const nested of [module.rootModule, chunkGraph.getIssuer?.(module)]) if (nested) collectModuleResources(nested, resources, seen);
+		for (const nested of module.modules ?? []) collectModuleResources(nested, resources, seen);
+		for (const dependency of module.dependencies ?? []) {
+			const dependencyLike = dependency;
+			for (const candidate of [dependencyLike.request, dependencyLike.userRequest]) {
+				if (typeof candidate !== "string") continue;
+				const normalized = normalizeResource(candidate, module);
+				if (normalized) resources.add(normalized);
+			}
+			const dependencyModule = chunkGraph.getModule?.(dependency);
+			if (dependencyModule) collectModuleResources(dependencyModule, resources, seen);
+		}
+	};
+	for (const chunk of chunks) {
+		const cssFiles = toChunkFiles(chunk.files).filter((file) => cssMatcher(file));
+		if (cssFiles.length === 0) continue;
+		const modules = chunkGraph.getChunkModulesIterable(chunk);
+		if (!modules) continue;
+		const cssResources = /* @__PURE__ */ new Set();
+		for (const module of modules) collectModuleResources(module, cssResources);
+		if (cssResources.size === 0) continue;
+		for (const cssFile of cssFiles) resourcesByAsset.set(cssFile, cssResources);
+	}
+	return resourcesByAsset;
+}
+function createAssetHashByChunkMap(chunks) {
+	const partsByFile = /* @__PURE__ */ new Map();
+	for (const chunk of chunks) {
+		const hash = typeof chunk.hash === "string" ? chunk.hash : void 0;
+		if (!hash) continue;
+		const chunkId = String(chunk.id ?? chunk.name ?? "");
+		for (const file of toChunkFiles(chunk.files)) {
+			if (!file) continue;
+			let parts = partsByFile.get(file);
+			if (!parts) {
+				parts = [];
+				partsByFile.set(file, parts);
+			}
+			parts.push(`${chunkId}:${hash}`);
+		}
+	}
+	const hashByFile = /* @__PURE__ */ new Map();
+	for (const [file, parts] of partsByFile.entries()) hashByFile.set(file, parts.sort().join("|"));
+	return hashByFile;
+}
+function createRuntimeAwareCssHash(assetHash, sourceHash, runtimeSetHash) {
+	return `${assetHash ?? sourceHash}:${runtimeSetHash}`;
+}
+function isWatchFileInRuntimeDependencies(file, dependencies) {
+	const normalizedFile = normalizeWatchPath(file);
+	for (const dependency of dependencies.files ?? []) if (normalizeWatchPath(dependency) === normalizedFile) return true;
+	for (const context of dependencies.contexts ?? []) if (isFileInContext(normalizedFile, context)) return true;
+	return false;
+}
+//#endregion
+//#region src/bundlers/webpack/shared/css-loader-runtime.ts
+function isWebpackCssLoaderRuntimeSource(source) {
+	return source.includes("___CSS_LOADER_EXPORT___") && source.includes("___CSS_LOADER_API_IMPORT___") && source.includes("module.exports = ___CSS_LOADER_EXPORT___");
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/pipeline-helpers.ts
+const WEBPACK_CSS_HANDLER_OPTIONS_CACHE_MAX = 128;
+function removeTailwindV4StandaloneHostPreflightRule(source) {
+	if (!source.includes("--theme(")) return source;
+	try {
+		const root = postcss.parse(source);
+		let changed = false;
+		root.walkRules((rule) => {
+			if (rule.selector.trim() !== ":host") return;
+			if (!rule.nodes?.some((node) => node.type === "decl" && node.value?.includes("--theme("))) return;
+			rule.remove();
+			changed = true;
+		});
+		return changed ? root.toString() : source;
+	} catch {
+		return source;
+	}
+}
+function isRuntimeTransformCandidate(candidate) {
+	return candidate.length > 0 && !candidate.includes("=") && !candidate.includes("<") && !candidate.includes(">") && !candidate.includes("${");
+}
+function collectRuntimeTokenSignatureParts(source) {
+	return source.match(/[\w-]+_[A-Z][\w-]*/gi) ?? [];
+}
+function hasMissingRuntimeCandidates(classSet, candidates) {
+	if (!classSet || !candidates?.size) return false;
+	for (const candidate of candidates) if (isRuntimeTransformCandidate(candidate) && !classSet.has(candidate)) return true;
+	return false;
+}
+function resolveGeneratedCssRuntimeCandidates(source, fallbackClassSet) {
+	const classSet = collectGeneratedCssRuntimeCandidates(source);
+	if (classSet.size > 0 || fallbackClassSet === void 0) return classSet;
+	return fallbackClassSet;
+}
+function getRuntimeClassSetSync(tailwindRuntime) {
+	if (typeof tailwindRuntime.getClassSetSync !== "function") return /* @__PURE__ */ new Set();
+	try {
+		return new Set(tailwindRuntime.getClassSetSync() ?? []);
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function toMb(bytes) {
+	return Math.round(bytes / 1024 / 1024);
+}
+function pruneMapToMaxSize(map, maxSize) {
+	while (map.size > maxSize) {
+		const oldestKey = map.keys().next().value;
+		if (oldestKey === void 0) break;
+		map.delete(oldestKey);
+	}
+}
+function stripTrailingLineWhitespace(source) {
+	return source.replace(/[ \t]+$/gm, "");
+}
+function pruneWebpackCssHandlerOptionCaches(cssHandlerOptionsCache, cssUserHandlerOptionsCache, activeCssFiles) {
+	const activeSuffixes = [...activeCssFiles].map((file) => `:${file}`);
+	for (const key of cssHandlerOptionsCache.keys()) if (!activeSuffixes.some((suffix) => key.endsWith(suffix))) cssHandlerOptionsCache.delete(key);
+	for (const key of cssUserHandlerOptionsCache.keys()) if (!activeSuffixes.some((suffix) => key.endsWith(suffix))) cssUserHandlerOptionsCache.delete(key);
+	pruneMapToMaxSize(cssHandlerOptionsCache, WEBPACK_CSS_HANDLER_OPTIONS_CACHE_MAX);
+	pruneMapToMaxSize(cssUserHandlerOptionsCache, WEBPACK_CSS_HANDLER_OPTIONS_CACHE_MAX);
+}
+function resolveWebpackGeneratorRawSource(rawSource, cssHandlerOptions) {
+	const sourceCss = cssHandlerOptions.sourceOptions?.sourceCss;
+	if (sourceCss && (hasTailwindRootDirectives(sourceCss, { importFallback: true }) || hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || hasTailwindApplyDirective(sourceCss) || hasTailwindGeneratedCss(sourceCss) || hasTailwindGeneratedCssMarkers(sourceCss))) return sourceCss;
+	return rawSource;
+}
+function hasUsableWebpackGeneratorCssSources(cssSources) {
+	return Array.isArray(cssSources) && cssSources.some((source) => typeof source?.css === "string" && source.css.length > 0);
+}
+function normalizeWebpackGeneratorCssSources(cssSources) {
+	if (!Array.isArray(cssSources)) return;
+	const normalized = cssSources.filter((source) => typeof source?.css === "string" && source.css.length > 0);
+	return normalized.length > 0 ? normalized : void 0;
+}
+function hasProcessedCssAssetUrl(css) {
+	return /url\(\s*["']?data:/i.test(css);
+}
+function shouldUseWebpackAssetAsGeneratorUserCss(rawSource, generatorRawSource, options = {}) {
+	return rawSource !== generatorRawSource && (options.processed === true || !rawSource.includes("data:")) && !hasTailwindRootDirectives(rawSource, { importFallback: true }) && !hasTailwindSourceDirectives(rawSource, { importFallback: true }) && !hasTailwindApplyDirective(rawSource) && /(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i.test(rawSource) && (!hasTailwindGeneratedCssMarkers(rawSource) || hasAdditionalWebpackAssetUserCssMarkers(rawSource, generatorRawSource));
+}
+function collectWebpackAssetUserCssMarkers(source) {
+	const markers = /* @__PURE__ */ new Set();
+	for (const match of source.matchAll(/\.((?:\\.|[_a-z\u00A0-\uFFFF-])(?:\\.|[\w\u00A0-\uFFFF-])*)/gi)) markers.add(`class:${match[1]}`);
+	for (const match of source.matchAll(/@(?:-[\w-]+-)?keyframes\s+((?:\\.|[-\w\u00A0-\uFFFF])+)/gi)) markers.add(`keyframes:${match[1]}`);
+	try {
+		const root = postcss.parse(source);
+		root.walkRules((rule) => {
+			for (const selector of rule.selectors) if (!/(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i.test(selector)) markers.add(`selector:${selector.trim().replace(/\s+/g, " ")}`);
+			rule.walkDecls((decl) => {
+				if (decl.prop.startsWith("--")) markers.add(`custom-property:${decl.prop}`);
+			});
+		});
+		root.walkAtRules("font-face", (rule) => {
+			rule.walkDecls("font-family", (decl) => {
+				markers.add(`font-face:${decl.value.trim()}`);
+			});
+		});
+	} catch {}
+	return markers;
+}
+const WEBPACK_TAILWIND_GENERATED_LAYER_NAMES = new Set([
+	"theme",
+	"base",
+	"utilities"
+]);
+const WEBPACK_TAILWIND_UTILITY_RULE_MARKER_RE = /(?:^|[^\w-])\.[^,{]{0,512}(?:\\:|\\\[|\\#)/;
+const WEBPACK_TAILWIND_UTILITY_PREFIX_RE = /^\.(?:-?(?:bg|text|border|ring|shadow|drop-shadow|[pmwhz]|px|py|pt|pr|pb|pl|mx|my|mt|mr|mb|ml|min-w|min-h|max-w|max-h|flex|grid|inline|block|hidden|rounded|opacity|translate|scale|rotate|skew|top|right|bottom|left|inset|gap|font|leading|tracking|underline|container)(?:[\-\\{]|$)|\\\[)/;
+function parseWebpackCssLayerNames(params) {
+	return params.split(",").map((name) => name.trim()).filter(Boolean);
+}
+function removeWebpackTailwindGeneratedAssetCss(source) {
+	const cleaned = removeTailwindV4GeneratedUserCssArtifacts(source);
+	try {
+		const root = postcss.parse(cleaned);
+		let changed = false;
+		root.walkAtRules("layer", (rule) => {
+			const names = parseWebpackCssLayerNames(rule.params);
+			const hasGeneratedLayerName = names.some((name) => WEBPACK_TAILWIND_GENERATED_LAYER_NAMES.has(name));
+			const isLayerDeclaration = rule.nodes === void 0;
+			const shouldRemoveLayer = isLayerDeclaration ? hasGeneratedLayerName : names.length > 0 && names.every((name) => WEBPACK_TAILWIND_GENERATED_LAYER_NAMES.has(name));
+			if (shouldRemoveLayer && isLayerDeclaration) {
+				rule.remove();
+				changed = true;
+				return;
+			}
+			if (shouldRemoveLayer && !names.includes("utilities")) {
+				rule.remove();
+				changed = true;
+				return;
+			}
+			if (shouldRemoveLayer) {
+				rule.walkRules((nestedRule) => {
+					const selector = nestedRule.selector.trim();
+					if (WEBPACK_TAILWIND_UTILITY_RULE_MARKER_RE.test(selector) || WEBPACK_TAILWIND_UTILITY_PREFIX_RE.test(selector)) {
+						nestedRule.remove();
+						changed = true;
+					}
+				});
+				if (rule.nodes?.length === 0) {
+					rule.remove();
+					changed = true;
+				}
+			}
+		});
+		root.walkAtRules((rule) => {
+			if (rule.nodes !== void 0 && rule.nodes.length === 0) {
+				rule.remove();
+				changed = true;
+			}
+		});
+		return changed ? root.toString() : cleaned;
+	} catch {
+		return cleaned;
+	}
+}
+function collectWebpackCssRuleIdentityMarkers(source) {
+	const markers = /* @__PURE__ */ new Set();
+	try {
+		const root = postcss.parse(source);
+		root.walkRules((rule) => {
+			for (const selector of rule.selectors) for (const match of selector.matchAll(/\.((?:\\.|[_a-z\u00A0-\uFFFF-])(?:\\.|[\w\u00A0-\uFFFF-])*)/gi)) markers.add(`class:${match[1]}`);
+		});
+		root.walkAtRules("keyframes", (rule) => {
+			if (rule.params) markers.add(`keyframes:${rule.params}`);
+		});
+	} catch {}
+	return markers;
+}
+function unescapeCssIdentifier(value) {
+	return value.replace(/\\([0-9a-f]{1,6}\s?|.)/gi, (_match, escaped) => {
+		const hex = escaped.trim();
+		if (/^[0-9a-f]+$/i.test(hex)) return String.fromCodePoint(Number.parseInt(hex, 16));
+		return escaped;
+	});
+}
+function collectGeneratedCssRuntimeCandidates(source) {
+	const candidates = /* @__PURE__ */ new Set();
+	if (hasBundlerGeneratedCssMarker(source) || !hasTailwindGeneratedCss(source) && !hasTailwindGeneratedCssMarkers(source)) return candidates;
+	try {
+		postcss.parse(source).walkRules((rule) => {
+			for (const selector of rule.selectors) for (const match of selector.matchAll(/\.((?:\\.|[\w\u00A0-\uFFFF-])(?:\\.|[\w\u00A0-\uFFFF-])*)/g)) {
+				const candidate = unescapeCssIdentifier(match[1]);
+				if (isRuntimeTransformCandidate(candidate)) candidates.add(candidate);
+			}
+		});
+	} catch {}
+	return candidates;
+}
+function hasAdditionalWebpackAssetUserCssMarkers(rawSource, generatorRawSource) {
+	const rawMarkers = collectWebpackAssetUserCssMarkers(rawSource);
+	if (rawMarkers.size === 0) return false;
+	const generatorMarkers = collectWebpackAssetUserCssMarkers(generatorRawSource);
+	for (const marker of rawMarkers) if (!generatorMarkers.has(marker)) return true;
+	return false;
+}
+function hasWebpackTailwindSourceDirectives(source) {
+	return Boolean(source) && (hasTailwindRootDirectives(source, { importFallback: true }) || hasTailwindSourceDirectives(source, { importFallback: true }) || hasTailwindApplyDirective(source) || hasTailwindGeneratedCss(source) || hasTailwindGeneratedCssMarkers(source));
+}
+function isWebpackTailwindImportRequest(request) {
+	return request === "tailwindcss" || request === "tailwindcss4" || request?.startsWith("tailwindcss/") || request?.startsWith("tailwindcss4/") || request === "weapp-tailwindcss" || request?.startsWith("weapp-tailwindcss/");
+}
+function removeWebpackGeneratorNonTailwindImports(source) {
+	if (!source?.includes("@import")) return source;
+	try {
+		const root = postcss.parse(source);
+		let changed = false;
+		root.walkAtRules("import", (rule) => {
+			if (isWebpackTailwindImportRequest(parseImportRequest(rule.params))) return;
+			rule.remove();
+			changed = true;
+		});
+		return changed ? root.toString() : source;
+	} catch {
+		return source;
+	}
+}
+function isWebpackCssSourceRepresentedInAsset(rawSource, sourceCss) {
+	if (!sourceCss || !hasWebpackTailwindSourceDirectives(sourceCss)) return false;
+	const sourceMarkers = collectWebpackCssRuleIdentityMarkers(sourceCss);
+	if (sourceMarkers.size === 0) return false;
+	const rawMarkers = collectWebpackCssRuleIdentityMarkers(rawSource);
+	for (const marker of sourceMarkers) if (!rawMarkers.has(marker)) return false;
+	return true;
+}
+function createWebpackGeneratorCssSource(file, css) {
+	if (!file || !css || !hasWebpackTailwindSourceDirectives(css)) return;
+	return {
+		file,
+		base: path.dirname(file),
+		css,
+		dependencies: [file]
+	};
+}
+function createWebpackUserCssSourceAppend(sources, generatorRawSource, currentSourceFile, shouldIncludeSource) {
+	const matchedSources = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const source of sources) {
+		const css = source.css;
+		if (!css || seen.has(css)) continue;
+		if (shouldIncludeSource && !shouldIncludeSource(source.file)) continue;
+		seen.add(css);
+		if ((source.processed === true || !css.includes("data:")) && hasAdditionalWebpackAssetUserCssMarkers(css, generatorRawSource)) matchedSources.push({
+			css,
+			file: source.file,
+			processed: source.processed === true
+		});
+	}
+	const currentFile = currentSourceFile ? path.resolve(currentSourceFile) : void 0;
+	const parts = matchedSources.sort((a, b) => {
+		const aCurrent = currentFile !== void 0 && path.resolve(a.file) === currentFile;
+		if (aCurrent !== (currentFile !== void 0 && path.resolve(b.file) === currentFile)) return aCurrent ? -1 : 1;
+		return a.file.localeCompare(b.file);
+	}).map((source) => source.css);
+	return parts.length > 0 ? {
+		css: parts.join("\n"),
+		processed: matchedSources.every((source) => source.processed)
+	} : void 0;
+}
+function createWebpackGeneratorUserCssSourceAppend(...sources) {
+	const parts = sources.filter((source) => source !== void 0 && source.css.trim().length > 0);
+	if (parts.length === 0) return;
+	let css = "";
+	const usedParts = [];
+	for (const source of parts) {
+		const nextCss = css.trim().length > 0 ? filterExistingCssRules(css, source.css) : source.css;
+		if (!(nextCss.trim().length > 0)) continue;
+		css = createCssSourceOrderAppend(css, nextCss);
+		usedParts.push(source);
+	}
+	return {
+		css,
+		processed: usedParts.every((source) => source.processed)
+	};
+}
+function resolveWebpackMemoryDebugStats(context) {
+	if (process.env["WEAPP_TW_HMR_MEMORY_DEBUG"] !== "1") return;
+	const memory = process.memoryUsage();
+	const processCacheInstanceSize = context.cache.instance.size;
+	const processCacheHashMapSize = context.cache.hashMap.size;
+	return {
+		phase: context.phase,
+		process: {
+			rssMb: toMb(memory.rss),
+			heapTotalMb: toMb(memory.heapTotal),
+			heapUsedMb: toMb(memory.heapUsed),
+			externalMb: toMb(memory.external),
+			arrayBuffersMb: toMb(memory.arrayBuffers)
+		},
+		assets: {
+			active: context.activeAssetFiles,
+			activeCss: context.activeCssFiles
+		},
+		processCache: {
+			instance: processCacheInstanceSize,
+			hashMap: processCacheHashMapSize,
+			activeCacheKeys: context.activeProcessCacheKeys.size,
+			activeHashKeys: context.activeProcessHashKeys.size,
+			staleCacheKeys: Math.max(0, processCacheInstanceSize - context.activeProcessCacheKeys.size),
+			staleHashKeys: Math.max(0, processCacheHashMapSize - context.activeProcessHashKeys.size),
+			pruned: true,
+			pruneSkipped: false
+		},
+		webpackCss: {
+			handlerOptions: context.cssHandlerOptionsCache.size,
+			userHandlerOptions: context.cssUserHandlerOptionsCache.size,
+			maxHandlerOptions: WEBPACK_CSS_HANDLER_OPTIONS_CACHE_MAX
+		},
+		sourceCandidateScan: context.sourceCandidateScan,
+		tailwind: { v4: getTailwindV4IncrementalGenerateCacheStats() }
+	};
+}
+function shouldInjectWebpackCssTracePreflight(appType, cssHandlerOptions) {
+	return appType !== "mpx" || cssHandlerOptions.isMainChunk !== false;
+}
+function finalizeMiniProgramUserCssAssetSource(source, compilerOptions, isWebGeneratorTarget, options = {}) {
+	const styleOptions = resolveStyleOptionsFromContext(compilerOptions);
+	if (isWebGeneratorTarget) return source;
+	return stripMiniProgramCssSpecificityPlaceholders(removeTailwindV4StandaloneHostPreflightRule(finalizeMiniProgramCss(removeMiniProgramHoverSelectors(source, styleOptions.cssRemoveHoverPseudoClass), {
+		cssPreflight: options.cssPreflight !== false && !hasMiniProgramTailwindV4PreflightReset(source) ? compilerOptions.cssPreflight : void 0,
+		isTailwindcssV4: true,
+		tailwindcssV4GradientFallback: styleOptions.tailwindcssV4GradientFallback
+	})));
+}
+function shouldFallbackToWebpackUserCssOnGeneratorError(options) {
+	return !hasTailwindRootDirectives(options.generatorRawSource, { importFallback: true }) && !hasTailwindSourceDirectives(options.generatorRawSource, { importFallback: true }) && !hasTailwindApplyDirective(options.generatorRawSource) && !options.hasExplicitTailwindV4SourceCss && options.configuredMainCssEntryFilesLength === 0;
+}
+function isWindowsAbsoluteResourcePath(file) {
+	return /^[a-z]:[\\/]/i.test(file) || /^[/\\]{2}[^/\\]/.test(file);
+}
+function isPosixAbsoluteResourcePath(file) {
+	return file.startsWith("/");
+}
+function resolveWebpackResourcePath(file, base) {
+	if (isWindowsAbsoluteResourcePath(file)) return path.win32.resolve(file);
+	if (isPosixAbsoluteResourcePath(file)) return path.posix.resolve(file);
+	if (base) {
+		if (isWindowsAbsoluteResourcePath(base)) return path.win32.resolve(base, file);
+		if (isPosixAbsoluteResourcePath(base)) return path.posix.resolve(base, file);
+		return path.resolve(base, file);
+	}
+}
+function dirnameWebpackResourcePath(file) {
+	if (isWindowsAbsoluteResourcePath(file)) return path.win32.dirname(file);
+	if (isPosixAbsoluteResourcePath(file)) return path.posix.dirname(file);
+	return path.dirname(file);
+}
+function resolveWebpackCssAssetModuleResource(resource, issuer, options) {
+	if (!isCssLikeModuleResource(resource, options.cssMatcher, options.appType)) return;
+	const normalized = stripResourceQuery(resource);
+	if (!normalized) return;
+	const absoluteResource = resolveWebpackResourcePath(normalized);
+	if (absoluteResource) return absoluteResource;
+	const issuerResource = issuer?.resource ? stripResourceQuery(issuer.resource) : void 0;
+	const issuerResourcePath = issuerResource ? resolveWebpackResourcePath(issuerResource) : void 0;
+	return resolveWebpackResourcePath(normalized, issuerResourcePath ? dirnameWebpackResourcePath(issuerResourcePath) : issuer?.context);
+}
+function isSameWebpackCssSourceScope(options) {
+	if (!options.currentSourceFile) return false;
+	const candidateKey = resolveWebpackResourcePath(options.candidateSourceFile) ?? path.resolve(options.candidateSourceFile);
+	if (candidateKey === (resolveWebpackResourcePath(options.currentSourceFile) ?? path.resolve(options.currentSourceFile))) return true;
+	const outputResources = options.resourcesByAsset.get(options.outputFile);
+	if (!outputResources) return false;
+	return [...outputResources].some((resource) => {
+		return (resolveWebpackResourcePath(resource) ?? path.resolve(resource)) === candidateKey;
+	});
+}
+function shouldAppendCurrentWebpackAssetUserCss(options) {
+	const hasGeneratedAssetUserCss = options.currentAssetLooksGenerated && options.currentAssetHasUserCss;
+	return !options.currentAssetHasBundlerGeneratedMarker && !options.shouldPreserveGeneratedWebAssetUserCss && (hasGeneratedAssetUserCss || !options.sourceCssProcessed || options.registeredUserRawSource === void 0 || options.currentAssetHasUserCss) && !(options.sourceCssProcessed && options.currentAssetLooksGenerated && !options.currentAssetHasUserCss);
+}
+function createWebpackCurrentAssetUserRawSource(options) {
+	if (!options.shouldAppendCurrentAssetUserCss) return;
+	if (options.sourceCssProcessed) return {
+		css: options.currentAssetUserCssSource,
+		processed: true
+	};
+	if (!options.currentAssetHasUserCss) return;
+	return {
+		css: options.currentAssetUserCssSource,
+		processed: options.currentAssetLooksGenerated
+	};
+}
+function finalizeTracedWebpackCssAsset(css, cssHandlerOptions, options) {
+	const traced = options.annotateCss(css);
+	if (options.isWebGeneratorTarget || !isCssSourceTraceEnabled(options.compilerOptions)) return traced;
+	return finalizeMiniProgramUserCssAssetSource(traced, options.compilerOptions, options.isWebGeneratorTarget, { cssPreflight: shouldInjectWebpackCssTracePreflight(options.compilerOptions.appType, cssHandlerOptions) });
+}
+function finalizeWebpackCssAssetSource(source, compilerOptions, isWebGeneratorTarget, options = {}) {
+	const styleOptions = resolveStyleOptionsFromContext(compilerOptions);
+	if (isWebGeneratorTarget) {
+		if (options.generatedCss === true) return stripTrailingLineWhitespace(stripUnmatchedTailwindSourceMediaCloseFragments(stripTailwindSourceMediaFragments(stripBundlerGeneratedCssMarkers(source))));
+		return stripTrailingLineWhitespace(stripUnmatchedTailwindSourceMediaCloseFragments(stripTailwindSourceMediaFragments(removeTailwindV4GeneratorAtRules(removeTailwindSourceDirectives(stripBundlerGeneratedCssMarkers(source), { importFallback: true })))));
+	}
+	let finalized = removeTailwindSourceDirectives(stripBundlerGeneratedCssMarkers(source), { importFallback: true });
+	if (options.generatedCss !== true) return stripMiniProgramCssSpecificityPlaceholders(removeMiniProgramHoverSelectors(finalized, styleOptions.cssRemoveHoverPseudoClass));
+	try {
+		finalized = pruneMiniProgramGeneratedCss(finalized, { preservePreflight: true });
+	} catch {
+		finalized = finalizeMiniProgramCss(finalized, {
+			cssPreflight: !hasMiniProgramTailwindV4PreflightReset(finalized) ? compilerOptions.cssPreflight : void 0,
+			isTailwindcssV4: true,
+			tailwindcssV4GradientFallback: styleOptions.tailwindcssV4GradientFallback
+		});
+	}
+	return stripMiniProgramCssSpecificityPlaceholders(removeMiniProgramHoverSelectors(finalized, styleOptions.cssRemoveHoverPseudoClass));
+}
+function collectWebpackJsRuntimeCandidatesFromAssets(options) {
+	if (options.isWebGeneratorTarget) return;
+	const candidates = /* @__PURE__ */ new Set();
+	for (const file of options.jsAssets) {
+		const sourceLike = options.getAssetSource(file);
+		if (sourceLike === void 0) continue;
+		const source = stringifyWebpackSourceLike(sourceLike);
+		for (const candidate of collectStrictEscapedRuntimeCandidates(source, MappingChars2String, options.escapeFragments)) if (isRuntimeTransformCandidate(candidate)) candidates.add(candidate);
+	}
+	return candidates;
+}
+function collectWebpackJsRuntimeTokenSignature(options) {
+	if (options.isWebGeneratorTarget) return "";
+	const tokens = [];
+	for (const file of options.jsAssets) {
+		const sourceLike = options.getAssetSource(file);
+		if (sourceLike === void 0) continue;
+		tokens.push(...collectRuntimeTokenSignatureParts(stringifyWebpackSourceLike(sourceLike)));
+	}
+	return tokens.sort().join("\n");
+}
+function addRuntimeTransformCandidates(target, candidates) {
+	if (!candidates?.size) return;
+	for (const candidate of candidates) if (isRuntimeTransformCandidate(candidate)) target.add(candidate);
+}
+function createWebpackCssSourceTraceTokenSources(compilerOptions, webpackSourceCandidates) {
+	if (!isCssSourceTraceEnabled(compilerOptions) || !webpackSourceCandidates) return;
+	return createCssTokenSourceMap(webpackSourceCandidates.tokenSources, compilerOptions);
+}
+function stringifyOptionalWebpackSourceValue(value) {
+	return typeof value === "string" ? value : value?.toString() ?? "";
+}
+function stringifyWebpackSourceLike(source) {
+	if (typeof source === "string") return source;
+	const value = source.source();
+	return typeof value === "string" ? value : value.toString();
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/css-source-resolvers.ts
+function createWebpackCssSourceResolvers(options) {
+	const { activeWebpackAssetResourceFiles, appType, compilerOptions, compilation, cssAssetResources, cssHandlerOptionsCache, cssSources, cssUserHandlerOptionsCache, groupedCssEntriesLength, singleCssAssetFile, isWebGeneratorTarget, outputDir, runtimeState } = options;
+	const hasConfiguredTailwindV4SourceRoots = () => {
+		const tailwindOptions = resolveTailwindcssOptions(runtimeState.tailwindRuntime.options);
+		return (tailwindOptions?.v4?.cssEntries?.length ?? 0) > 0 || (tailwindOptions?.v4?.cssSources?.length ?? 0) > 0;
+	};
+	const configuredMainCssEntryFiles = (() => {
+		return [...resolveTailwindcssOptions(runtimeState.tailwindRuntime.options)?.v4?.cssEntries ?? []].filter((file) => typeof file === "string" && file.length > 0).map((file) => path.resolve(file));
+	})();
+	const inferredMainCssFiles = inferWebpackMainCssFiles(compilation.chunks, compilerOptions.cssMatcher, {
+		mainSourceFiles: new Set(configuredMainCssEntryFiles),
+		resourcesByAsset: cssAssetResources
+	});
+	const singleConfiguredCssAsset = isWebGeneratorTarget && configuredMainCssEntryFiles.length > 0 && groupedCssEntriesLength === 1 ? singleCssAssetFile : void 0;
+	const isMainCssChunk = (file) => compilerOptions.mainCssChunkMatcher(file, appType) || inferredMainCssFiles.has(file) || file === singleConfiguredCssAsset;
+	const activeWebpackCssSourceFiles = /* @__PURE__ */ new Set();
+	const resolveConfiguredMainCssSourceFile = (file) => {
+		if (!isMainCssChunk(file)) return;
+		for (const sourceFile of configuredMainCssEntryFiles) if (cssSources.has(sourceFile)) {
+			activeWebpackCssSourceFiles.add(sourceFile);
+			return sourceFile;
+		}
+	};
+	const resolveWebpackCssSourceFile = (file, rawSource) => {
+		const assetResources = cssAssetResources.get(file);
+		const activeAssetResource = resolveSingleActiveWebpackCssResource(assetResources, activeWebpackAssetResourceFiles);
+		if (cssSources.size === 0) {
+			if (activeAssetResource) {
+				activeWebpackCssSourceFiles.add(activeAssetResource);
+				return activeAssetResource;
+			}
+			if (assetResources && assetResources.size > 0) return;
+			return resolveConfiguredMainCssSourceFile(file);
+		}
+		const resourceMatches = [...assetResources ?? []].filter((sourceFile) => cssSources.has(sourceFile)).sort();
+		if (resourceMatches.length === 1) {
+			const sourceFile = resourceMatches[0];
+			activeWebpackCssSourceFiles.add(sourceFile);
+			return sourceFile;
+		}
+		const tailwindSourceMatches = resourceMatches.filter((sourceFile) => {
+			const sourceCss = cssSources.get(sourceFile)?.css;
+			return sourceCss && (hasTailwindRootDirectives(sourceCss, { importFallback: true }) || hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || hasTailwindApplyDirective(sourceCss) || hasTailwindGeneratedCss(sourceCss) || hasTailwindGeneratedCssMarkers(sourceCss));
+		});
+		if (tailwindSourceMatches.length === 1) {
+			const sourceFile = tailwindSourceMatches[0];
+			activeWebpackCssSourceFiles.add(sourceFile);
+			return sourceFile;
+		}
+		if (activeAssetResource) {
+			activeWebpackCssSourceFiles.add(activeAssetResource);
+			return activeAssetResource;
+		}
+		if (rawSource) {
+			const representedTailwindSourceMatches = [...cssSources.entries()].filter(([, source]) => isWebpackCssSourceRepresentedInAsset(rawSource, source.css)).map(([sourceFile]) => ({
+				sourceFile,
+				score: scoreTailwindV4CssSourceFileMatch(file, sourceFile, {
+					outputRoot: outputDir,
+					projectRoot: compilerOptions.tailwindcssBasedir,
+					cwd: compilerOptions.tailwindcssBasedir
+				})
+			})).filter((match) => match.score > 0).sort((a, b) => b.score - a.score || a.sourceFile.localeCompare(b.sourceFile));
+			const bestScore = representedTailwindSourceMatches[0]?.score ?? 0;
+			const bestMatches = representedTailwindSourceMatches.filter((match) => match.score === bestScore);
+			if (bestMatches.length === 1) {
+				const sourceFile = bestMatches[0].sourceFile;
+				activeWebpackCssSourceFiles.add(sourceFile);
+				return sourceFile;
+			}
+		}
+		const pathMatches = [...cssSources.keys()].map((sourceFile) => ({
+			sourceFile,
+			score: scoreTailwindV4CssSourceFileMatch(file, sourceFile, {
+				outputRoot: outputDir,
+				projectRoot: compilerOptions.tailwindcssBasedir,
+				cwd: compilerOptions.tailwindcssBasedir
+			})
+		})).filter((match) => match.score >= 1e3).sort((a, b) => b.score - a.score || a.sourceFile.localeCompare(b.sourceFile));
+		const bestPathScore = pathMatches[0]?.score ?? 0;
+		const bestPathMatches = pathMatches.filter((match) => match.score === bestPathScore);
+		if (bestPathMatches.length === 1) {
+			const sourceFile = bestPathMatches[0].sourceFile;
+			activeWebpackCssSourceFiles.add(sourceFile);
+			return sourceFile;
+		}
+		if (assetResources && assetResources.size > 0) return;
+		return resolveConfiguredMainCssSourceFile(file);
+	};
+	const isSameWebpackSourceScope = (outputFile, candidateSourceFile, currentSourceFile) => isSameWebpackCssSourceScope({
+		candidateSourceFile,
+		currentSourceFile,
+		outputFile,
+		resourcesByAsset: cssAssetResources
+	});
+	const getCssHandlerOptions = (file, rawSource) => {
+		const majorVersion = runtimeState.tailwindRuntime.majorVersion;
+		const isMainChunk = isMainCssChunk(file);
+		const sourceFile = resolveWebpackCssSourceFile(file, rawSource);
+		const sourceCss = sourceFile ? cssSources.get(sourceFile)?.css : void 0;
+		const generatorSourceCss = removeWebpackGeneratorNonTailwindImports(sourceCss);
+		const generatorCssSource = createWebpackGeneratorCssSource(sourceFile, generatorSourceCss);
+		const cacheKey = [
+			majorVersion ?? "unknown",
+			isMainChunk ? "1" : "0",
+			sourceFile ?? "asset",
+			sourceCss === void 0 ? "source:0" : compilerOptions.cache.computeHash(sourceCss),
+			generatorSourceCss === sourceCss || generatorSourceCss === void 0 ? "generator-source:0" : compilerOptions.cache.computeHash(generatorSourceCss),
+			file
+		].join(":");
+		const cached = cssHandlerOptionsCache.get(cacheKey);
+		if (cached) return cached;
+		const created = {
+			isMainChunk,
+			postcssOptions: { options: { from: sourceFile ?? file } },
+			sourceOptions: {
+				outputRoot: outputDir,
+				...generatorCssSource === void 0 ? {} : { cssSources: [generatorCssSource] },
+				...generatorSourceCss === void 0 ? {} : { sourceCss: generatorSourceCss },
+				...sourceFile === void 0 ? {} : { sourceFile }
+			},
+			...normalizeStyleHandlerMajorVersion(majorVersion) === void 0 ? {} : { majorVersion: 4 }
+		};
+		cssHandlerOptionsCache.set(cacheKey, created);
+		return created;
+	};
+	const getCssUserHandlerOptions = (file) => {
+		const majorVersion = runtimeState.tailwindRuntime.majorVersion;
+		const sourceFile = resolveWebpackCssSourceFile(file);
+		const sourceCss = sourceFile ? cssSources.get(sourceFile)?.css : void 0;
+		const generatorSourceCss = removeWebpackGeneratorNonTailwindImports(sourceCss);
+		const cacheKey = [
+			majorVersion ?? "unknown",
+			sourceFile ?? "asset",
+			sourceCss === void 0 ? "source:0" : compilerOptions.cache.computeHash(sourceCss),
+			generatorSourceCss === sourceCss || generatorSourceCss === void 0 ? "generator-source:0" : compilerOptions.cache.computeHash(generatorSourceCss),
+			file
+		].join(":");
+		const cached = cssUserHandlerOptionsCache.get(cacheKey);
+		if (cached) return cached;
+		const created = {
+			...getCssHandlerOptions(file),
+			isMainChunk: false
+		};
+		cssUserHandlerOptionsCache.set(cacheKey, created);
+		return created;
+	};
+	return {
+		activeWebpackCssSourceFiles,
+		configuredMainCssEntryFiles,
+		getCssHandlerOptions,
+		getCssUserHandlerOptions,
+		hasConfiguredTailwindV4SourceRoots,
+		isSameWebpackSourceScope,
+		resolveWebpackCssSourceFile
+	};
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/helpers.ts
+function createChangedByType() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set(),
+		other: /* @__PURE__ */ new Set()
+	};
+}
+function createProcessFiles() {
+	return {
+		html: /* @__PURE__ */ new Set(),
+		js: /* @__PURE__ */ new Set(),
+		css: /* @__PURE__ */ new Set()
+	};
+}
+function markProcessFile(type, file, processFiles) {
+	if (type === "html" || type === "js" || type === "css") processFiles[type].add(file);
+}
+function buildWebpackBundleSnapshot(assets, opts, state, compilation) {
+	const sourceHashByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingSignatureByFile = /* @__PURE__ */ new Map();
+	const runtimeAffectingHashByFile = /* @__PURE__ */ new Map();
+	const changedByType = createChangedByType();
+	const runtimeAffectingChangedByType = createChangedByType();
+	const processFiles = createProcessFiles();
+	const entries = [];
+	const firstRun = state.iteration === 0 && state.sourceHashByFile.size === 0;
+	for (const [file, asset] of Object.entries(assets)) {
+		const type = classifyBundleEntry(file, opts);
+		if (type !== "html" && type !== "js") continue;
+		const source = stringifyWebpackSource(compilation?.getAsset(file)?.source.source() ?? asset.source());
+		const hash = opts.cache.computeHash(source);
+		sourceHashByFile.set(file, hash);
+		const previousHash = state.sourceHashByFile.get(file);
+		const changed = previousHash == null || previousHash !== hash;
+		const previousRuntimeAffectingHash = state.runtimeAffectingHashByFile.get(file);
+		const runtimeAffectingHash = !changed && previousRuntimeAffectingHash != null ? previousRuntimeAffectingHash : (() => {
+			const runtimeAffectingSignature = createRuntimeAffectingSourceSignature(source, type);
+			runtimeAffectingSignatureByFile.set(file, runtimeAffectingSignature);
+			return opts.cache.computeHash(runtimeAffectingSignature);
+		})();
+		runtimeAffectingHashByFile.set(file, runtimeAffectingHash);
+		if (changed) changedByType[type].add(file);
+		if (previousRuntimeAffectingHash == null || previousRuntimeAffectingHash !== runtimeAffectingHash) runtimeAffectingChangedByType[type].add(file);
+		if (firstRun) markProcessFile(type, file, processFiles);
+		else if (type === "html") processFiles.html.add(file);
+		else if (changed) processFiles.js.add(file);
+		entries.push({
+			file,
+			output: {
+				fileName: file,
+				name: void 0,
+				names: [],
+				needsCodeReference: false,
+				originalFileName: null,
+				originalFileNames: [],
+				source,
+				type: "asset"
+			},
+			source,
+			type
+		});
+	}
+	return {
+		entries,
+		jsEntries: /* @__PURE__ */ new Map(),
+		sourceHashByFile,
+		runtimeAffectingSignatureByFile,
+		runtimeAffectingHashByFile,
+		hasOmittedKnownFiles: false,
+		changedByType,
+		runtimeAffectingChangedByType,
+		processFiles,
+		linkedImpactsByEntry: /* @__PURE__ */ new Map()
+	};
+}
+function releaseWebpackBundleSnapshotSources(snapshot) {
+	for (const entry of snapshot.entries) {
+		entry.source = "";
+		if (entry.output.type === "asset") entry.output.source = "";
+		else entry.output.code = "";
+	}
+}
+function stringifyWebpackSource(source) {
+	if (typeof source === "string") return source;
+	return source?.toString() ?? "";
+}
+function createWebpackAssetUpdater(options) {
+	const getCurrentAssetSource = (file) => {
+		const asset = options.compilation.getAsset(file);
+		if (!asset) return;
+		return stringifyWebpackSource(asset.source.source());
+	};
+	const updateAssetIfChanged = (file, source, { compare = true, notifyUpdate = true } = {}) => {
+		if (!compare) {
+			options.compilation.updateAsset(file, typeof source === "string" ? new options.ConcatSource(source) : source);
+			return true;
+		}
+		const nextSource = typeof source === "string" ? source : stringifyWebpackSource(source.source());
+		const previousSource = getCurrentAssetSource(file);
+		if (previousSource === nextSource) {
+			options.debug("asset unchanged, skip update: %s", file);
+			return false;
+		}
+		options.compilation.updateAsset(file, typeof source === "string" ? new options.ConcatSource(source) : source);
+		if (notifyUpdate) options.onUpdate(file, previousSource ?? "", nextSource);
+		return true;
+	};
+	return {
+		getCurrentAssetSource,
+		updateAssetIfChanged
+	};
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/js-module-graph.ts
+function createWebpackJsAssetModuleGraph(options) {
+	const jsAssets = /* @__PURE__ */ new Map();
+	for (const [file] of options.entries) if (options.compilerOptions.jsMatcher(file) || options.compilerOptions.wxsMatcher(file)) {
+		const absolute = toAbsoluteOutputPath(file, options.outputDir);
+		jsAssets.set(absolute, file);
+	}
+	return {
+		jsAssets,
+		moduleGraphOptions: {
+			resolve(specifier, importer) {
+				return resolveOutputSpecifier(specifier, importer, options.outputDir, (candidate) => jsAssets.has(candidate));
+			},
+			load: (id) => {
+				const assetName = jsAssets.get(id);
+				if (!assetName) return;
+				const asset = options.compilation.getAsset(assetName);
+				if (!asset) return;
+				const source = asset.source.source();
+				return source == null ? "" : String(source);
+			},
+			filter(id) {
+				return jsAssets.has(id);
+			}
+		}
+	};
+}
+function applyWebpackLinkedJsResults(options) {
+	if (!options.linked) return;
+	for (const [id, { code }] of Object.entries(options.linked)) {
+		const assetName = options.jsAssets.get(id);
+		if (!assetName) continue;
+		const asset = options.compilation.getAsset(assetName);
+		if (!asset) continue;
+		const previousSource = asset.source.source();
+		const previous = previousSource == null ? "" : String(previousSource);
+		if (previous === code) continue;
+		const source = new options.ConcatSource(code);
+		options.compilation.updateAsset(assetName, source);
+		options.compilerOptions.onUpdate(assetName, previous, code);
+		options.debug("js linked handle: %s", assetName);
+	}
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/source-candidate-cache.ts
+const WEBPACK_SOURCE_CANDIDATE_SCAN_CACHE_MAX = 2;
+function trimScanCache(cache) {
+	while (cache.size > WEBPACK_SOURCE_CANDIDATE_SCAN_CACHE_MAX) {
+		const oldestKey = cache.keys().next().value;
+		if (oldestKey === void 0) break;
+		cache.delete(oldestKey);
+	}
+}
+function collectWebpackSourceCandidateScanRoots(root, entries, explicit) {
+	const dedupedEntries = dedupeSourceEntries(entries);
+	if (dedupedEntries?.length) return [{
+		entries: dedupedEntries,
+		explicit,
+		root
+	}];
+	if (explicit && dedupedEntries !== void 0) return [];
+	return [{
+		entries: dedupedEntries,
+		root
+	}];
+}
+function dedupeSourceEntries(entries) {
+	if (!entries?.length) return entries;
+	const seen = /* @__PURE__ */ new Set();
+	const nextEntries = [];
+	for (const entry of entries) {
+		const key = JSON.stringify({
+			base: path.resolve(entry.base),
+			negated: entry.negated,
+			pattern: entry.pattern
+		});
+		if (seen.has(key)) continue;
+		seen.add(key);
+		nextEntries.push(entry);
+	}
+	return nextEntries;
+}
+function createWebpackSourceCandidateCacheRecord(collector, sourceScan, signatureHash) {
+	return {
+		getSourceCandidatesForEntries: (entries, options) => collector.valuesForEntries(entries, options),
+		signatureHash,
+		tokenSources: collector.sourcesForEntries(sourceScan?.entries)
+	};
+}
+function compactSnapshot(snapshot) {
+	return {
+		candidatesById: [],
+		cssCandidatesById: void 0,
+		inlineExcludedCandidates: snapshot.inlineExcludedCandidates,
+		inlineIncludedCandidates: snapshot.inlineIncludedCandidates,
+		scanCandidatesById: snapshot.scanCandidatesById,
+		sourceById: void 0,
+		transformCandidatesById: void 0
+	};
+}
+function normalizeChangedFiles(changedFiles) {
+	return new Set([...changedFiles ?? []].map((file) => resolveSourceScanPath(file)));
+}
+async function resolveScanFileSnapshot(file) {
+	try {
+		const stats = await stat(file);
+		const source = await readFile(file, "utf8");
+		return {
+			meta: {
+				contentHash: md5Hash(source),
+				mtimeMs: stats.mtimeMs,
+				size: stats.size
+			},
+			source
+		};
+	} catch (error) {
+		if ((typeof error === "object" && error !== null && "code" in error ? error.code : void 0) === "ENOENT") return;
+		throw error;
+	}
+}
+function isSameFileMeta(left, right) {
+	return left?.contentHash === right?.contentHash && left?.mtimeMs === right?.mtimeMs && left?.size === right?.size;
+}
+async function resolveScanFiles(roots, outDir) {
+	const files = /* @__PURE__ */ new Set();
+	await Promise.all(roots.map(async (root) => {
+		const rootFiles = await resolveSourceCandidateScanFiles({
+			entries: root.entries,
+			explicit: root.explicit,
+			filter: isSourceCandidateRequest,
+			outDir,
+			root: root.root
+		});
+		for (const file of rootFiles) files.add(resolveSourceScanPath(file));
+	}));
+	return files;
+}
+async function syncChangedScanFiles(collector, cachedScan, scanFiles, changedFiles) {
+	for (const file of cachedScan.files.keys()) {
+		if (scanFiles.has(file)) continue;
+		collector.remove(file);
+		cachedScan.files.delete(file);
+	}
+	await Promise.all([...scanFiles].map(async (file) => {
+		const nextSnapshot = await resolveScanFileSnapshot(file);
+		if (!nextSnapshot) {
+			collector.remove(file);
+			cachedScan.files.delete(file);
+			return;
+		}
+		const previousMeta = cachedScan.files.get(file);
+		if (previousMeta && isSameFileMeta(previousMeta, nextSnapshot.meta) && !changedFiles.has(file)) return;
+		await collector.sync(file, nextSnapshot.source);
+		cachedScan.files.set(file, nextSnapshot.meta);
+	}));
+}
+function createWebpackSourceCandidateScanCache() {
+	const scans = /* @__PURE__ */ new Map();
+	let lastHit = false;
+	let lastSignatureHash;
+	async function resolve({ changedFiles, collector, outDir, root, sourceScan, watchMode }) {
+		const explicit = sourceScan?.explicit ?? false;
+		const roots = collectWebpackSourceCandidateScanRoots(root, sourceScan?.entries, explicit);
+		const nextSignatureHash = md5Hash(createSourceCandidateScanSignature({
+			inlineCandidates: sourceScan?.inlineCandidates,
+			outDir,
+			roots,
+			scanAllSources: !explicit
+		}));
+		const scanFiles = await resolveScanFiles(roots, outDir);
+		const cachedScan = watchMode ? scans.get(nextSignatureHash) : void 0;
+		if (cachedScan) {
+			collector.restore(cachedScan.snapshot);
+			collector.syncInline(sourceScan?.inlineCandidates);
+			await syncChangedScanFiles(collector, cachedScan, scanFiles, normalizeChangedFiles(changedFiles));
+			cachedScan.snapshot = compactSnapshot(collector.snapshot());
+			lastHit = true;
+			lastSignatureHash = nextSignatureHash;
+			return createWebpackSourceCandidateCacheRecord(collector, sourceScan, nextSignatureHash);
+		}
+		collector.clearScan();
+		collector.syncInline(sourceScan?.inlineCandidates);
+		const files = /* @__PURE__ */ new Map();
+		await Promise.all([...scanFiles].map(async (file) => {
+			const nextSnapshot = await resolveScanFileSnapshot(file);
+			if (!nextSnapshot) return;
+			await collector.sync(file, nextSnapshot.source);
+			files.set(file, nextSnapshot.meta);
+		}));
+		if (watchMode) {
+			scans.set(nextSignatureHash, {
+				files,
+				snapshot: compactSnapshot(collector.snapshot())
+			});
+			trimScanCache(scans);
+		} else scans.clear();
+		lastHit = false;
+		lastSignatureHash = nextSignatureHash;
+		return createWebpackSourceCandidateCacheRecord(collector, sourceScan, nextSignatureHash);
+	}
+	function getMemoryStats() {
+		const cachedScans = [...scans.values()];
+		return {
+			entries: cachedScans.reduce((count, scan) => count + (scan.snapshot.scanCandidatesById?.length ?? scan.snapshot.candidatesById.length), 0),
+			files: cachedScans.reduce((count, scan) => count + scan.files.size, 0),
+			lastHit,
+			signatureHash: lastSignatureHash,
+			snapshots: scans.size
+		};
+	}
+	return {
+		getMemoryStats,
+		resolve
+	};
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets/source-candidate-refresh.ts
+async function refreshWebpackSourceCandidates(options) {
+	const root = options.compilerOptions.tailwindcssBasedir ?? process.cwd();
+	let sourceScan;
+	try {
+		sourceScan = await resolveViteSourceScanEntries(options.compilerOptions, options.runtimeState.tailwindRuntime, {
+			root,
+			outDir: options.outputDir
+		});
+	} catch (error) {
+		options.debug("webpack source candidate scan skipped: %O", error);
+		return;
+	}
+	if (!sourceScan || !sourceScan.explicit && !sourceScan.entries?.length && !sourceScan.inlineCandidates) return;
+	return options.scanCache.resolve({
+		changedFiles: options.watchChangedFiles,
+		collector: createSourceCandidateStore({ bareArbitraryValues: options.compilerOptions.arbitraryValues?.bareArbitraryValues }),
+		outDir: options.outputDir,
+		root,
+		sourceScan,
+		watchMode: options.watchMode
+	});
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-assets.ts
+function setupWebpackV5ProcessAssetsHook(options) {
+	const { compiler, options: compilerOptions, appType, runtimeState, getRuntimeRefreshRequirement, refreshRuntimeMetadata, isKnownWebpackProcessedCssAsset, isWebpackProcessedCssAsset, consumeRuntimeRefreshRequirement, isWatchMode, getWatchChangedFiles, runtimeClassSetManager, getWebpackCssSources, getWebpackGeneratedCssSources, pruneWebpackCssSources, prepareWebpackCssSources, debug } = options;
+	const { Compilation, sources } = compiler.webpack;
+	const { ConcatSource } = sources;
+	const isWebGeneratorTarget = compilerOptions.generator?.target === "web";
+	const cssHandlerOptionsCache = /* @__PURE__ */ new Map();
+	const cssUserHandlerOptionsCache = /* @__PURE__ */ new Map();
+	const webpackSourceCandidateScanCache = createWebpackSourceCandidateScanCache();
+	const bundleBuildState = createBundleBuildState();
+	const bundleRuntimeClassSetManager = runtimeClassSetManager ?? createBundleRuntimeClassSetManager();
+	const escapeFragments = createEscapeFragments(MappingChars2String);
+	const processedCssAssetSkipDecisionCache = /* @__PURE__ */ new Map();
+	let webpackWatchRuntimeScanInitialized = false;
+	compiler.hooks.compilation.tap(pluginName, (compilation) => {
+		compilation.hooks.processAssets.tapPromise({
+			name: pluginName,
+			stage: Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE
+		}, async (assets) => {
+			const entries = Object.entries(assets);
+			if (entries.length === 0) return;
+			const groupedEntries = getGroupedEntries(entries, compilerOptions);
+			if (isWebGeneratorTarget && groupedEntries.css.length === 0) return;
+			compilerOptions.onStart();
+			debug("start");
+			await runtimeState.readyPromise;
+			const hmrTimingStartedAt = performance.now();
+			for (const chunk of compilation.chunks) if (chunk.id && chunk.hash) compilerOptions.cache.calcHashValueChanged(chunk.id, chunk.hash);
+			const assetHashByChunk = createAssetHashByChunkMap(compilation.chunks);
+			const { updateAssetIfChanged } = createWebpackAssetUpdater({
+				compilation,
+				ConcatSource,
+				onUpdate: compilerOptions.onUpdate,
+				debug
+			});
+			const compilerOutputPath = compilation.compiler?.outputPath ?? compiler.outputPath;
+			const outputDir = compilerOutputPath ? path.resolve(compilerOutputPath) : compilation.outputOptions?.path ?? process.cwd();
+			const { jsAssets, moduleGraphOptions } = createWebpackJsAssetModuleGraph({
+				compilation,
+				compilerOptions,
+				entries,
+				outputDir
+			});
+			const watchMode = isWatchMode?.() === true;
+			const cssAssetResources = createWebpackCssAssetResourceMap(compilation.chunks, compilation.chunkGraph, compilerOptions.cssMatcher, (resource, issuer) => resolveWebpackCssAssetModuleResource(resource, issuer, {
+				appType,
+				cssMatcher: compilerOptions.cssMatcher
+			}));
+			const watchChangedFiles = new Set([...getWatchChangedFiles?.() ?? []].map((file) => path.resolve(file)));
+			const taskConcurrency = watchMode ? resolveTaskConcurrency(1) : void 0;
+			const activeProcessCacheKeys = /* @__PURE__ */ new Set();
+			const activeProcessHashKeys = /* @__PURE__ */ new Set();
+			const rememberProcessCacheKey = (cacheKey, hashKey = cacheKey) => {
+				activeProcessCacheKeys.add(cacheKey);
+				activeProcessHashKeys.add(hashKey);
+			};
+			const activeWebpackAssetResourceFiles = new Set([...cssAssetResources.values()].flatMap((resources) => [...resources].map((resource) => path.resolve(resource))));
+			const registeredWebpackCssSourceFiles = prepareWebpackCssSources?.(activeWebpackAssetResourceFiles) ?? /* @__PURE__ */ new Set();
+			for (const chunk of compilation.chunks) if (chunk.id) activeProcessHashKeys.add(chunk.id);
+			const cssSources = new Map([...getWebpackCssSources?.() ?? []].map(([file, source]) => [path.resolve(file), source]));
+			const generatedCssSources = new Map([...getWebpackGeneratedCssSources?.() ?? []].map(([file, source]) => [path.resolve(file), source]));
+			const { activeWebpackCssSourceFiles, configuredMainCssEntryFiles, getCssHandlerOptions, getCssUserHandlerOptions, hasConfiguredTailwindV4SourceRoots, isSameWebpackSourceScope, resolveWebpackCssSourceFile } = createWebpackCssSourceResolvers({
+				activeWebpackAssetResourceFiles,
+				appType,
+				compilerOptions,
+				compilation,
+				cssAssetResources,
+				cssHandlerOptionsCache,
+				cssSources,
+				cssUserHandlerOptionsCache,
+				groupedCssEntriesLength: groupedEntries.css.length,
+				singleCssAssetFile: groupedEntries.css[0]?.[0],
+				isWebGeneratorTarget,
+				outputDir,
+				runtimeState
+			});
+			const finalizeCssAssetSource = (source, options = {}) => finalizeWebpackCssAssetSource(source, compilerOptions, isWebGeneratorTarget, options);
+			const webpackSourceCandidates = !isWebGeneratorTarget && groupedEntries.css.length > 0 || cssSources.size > 0 || generatedCssSources.size > 0 || isCssSourceTraceEnabled(compilerOptions) ? await refreshWebpackSourceCandidates({
+				compilerOptions,
+				debug,
+				outputDir,
+				runtimeState,
+				scanCache: webpackSourceCandidateScanCache,
+				watchChangedFiles,
+				watchMode
+			}) : void 0;
+			const webpackSourceCandidateValueSignature = webpackSourceCandidates ? createCandidateSignature(webpackSourceCandidates.getSourceCandidatesForEntries(void 0)) : "source-candidates:0";
+			const cssSourceTraceTokenSources = createWebpackCssSourceTraceTokenSources(compilerOptions, webpackSourceCandidates);
+			const cssSourceTraceSignature = createCssSourceTraceCacheSignature(cssSourceTraceTokenSources, compilerOptions);
+			const annotateCss = (css) => annotateCssSourceTrace(css, {
+				opts: compilerOptions,
+				tokenSources: cssSourceTraceTokenSources
+			});
+			const finalizeTracedCss = (css, cssHandlerOptions) => finalizeTracedWebpackCssAsset(css, cssHandlerOptions, {
+				annotateCss,
+				compilerOptions,
+				isWebGeneratorTarget
+			});
+			const hasRuntimeTransformAssets = Boolean(!isWebGeneratorTarget && ((groupedEntries.html?.length ?? 0) > 0 || (groupedEntries.js?.length ?? 0) > 0));
+			const forceRuntimeRefresh = getRuntimeRefreshRequirement();
+			debug("processAssets ensure runtime set forceRefresh=%s major=%s", forceRuntimeRefresh, runtimeState.tailwindRuntime.majorVersion ?? "unknown");
+			let runtimeSet;
+			let runtimeAffectingSourceHash = "runtime-affecting:0";
+			if (isWebGeneratorTarget && !hasRuntimeTransformAssets && !forceRuntimeRefresh) runtimeSet = getRuntimeClassSetSync(runtimeState.tailwindRuntime);
+			else if (watchMode && !forceRuntimeRefresh) {
+				const baseRuntimeSet = getRuntimeClassSetSync(runtimeState.tailwindRuntime);
+				const snapshot = buildWebpackBundleSnapshot(assets, compilerOptions, bundleBuildState, compilation);
+				if (!webpackWatchRuntimeScanInitialized) for (const entry of snapshot.entries) snapshot.runtimeAffectingChangedByType[entry.type].add(entry.file);
+				runtimeAffectingSourceHash = compilerOptions.cache.computeHash([...groupedEntries.html.map(([file, source]) => `${file}:${compilerOptions.cache.computeHash(source.source().toString())}`), ...groupedEntries.js.map(([file, source]) => `${file}:${compilerOptions.cache.computeHash(source.source().toString())}`)].sort().join("\n\n"));
+				try {
+					runtimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.tailwindRuntime, snapshot, {
+						baseClassSet: baseRuntimeSet,
+						skipInitialFullScanWithBase: false
+					});
+				} catch (error) {
+					debug("webpack incremental runtime set sync failed, fallback to full collect: %O", error);
+					await bundleRuntimeClassSetManager.reset();
+					runtimeSet = getRuntimeClassSetSync(runtimeState.tailwindRuntime);
+				}
+				releaseWebpackBundleSnapshotSources(snapshot);
+				updateBundleBuildState(bundleBuildState, snapshot, /* @__PURE__ */ new Map(), { incremental: true });
+				webpackWatchRuntimeScanInitialized = true;
+			} else {
+				if (forceRuntimeRefresh) {
+					await bundleRuntimeClassSetManager.reset();
+					webpackWatchRuntimeScanInitialized = false;
+				}
+				runtimeSet = await ensureRuntimeClassSet(runtimeState, {
+					forceRefresh: forceRuntimeRefresh,
+					forceCollect: !watchMode || forceRuntimeRefresh,
+					clearCache: forceRuntimeRefresh,
+					allowEmpty: false
+				});
+			}
+			await refreshRuntimeMetadata(forceRuntimeRefresh);
+			consumeRuntimeRefreshRequirement();
+			const webpackSourceCandidateSet = webpackSourceCandidates?.getSourceCandidatesForEntries(void 0);
+			const generatorRuntimeSet = new Set(runtimeSet);
+			addRuntimeTransformCandidates(generatorRuntimeSet, webpackSourceCandidateSet);
+			const transformRuntimeSet = new Set(runtimeSet);
+			if (hasRuntimeTransformAssets) for (const [, originalSource] of groupedEntries.css) for (const candidate of collectGeneratedCssRuntimeCandidates(originalSource.source().toString())) transformRuntimeSet.add(candidate);
+			const transformedJsRuntimeCandidates = /* @__PURE__ */ new Set();
+			let currentJsRuntimeCandidates;
+			let currentJsRuntimeTokenSignature;
+			const getWebpackAssetSource = (file) => {
+				return compilation.getAsset(file)?.source;
+			};
+			const getCurrentJsRuntimeCandidates = () => {
+				if (currentJsRuntimeCandidates) return currentJsRuntimeCandidates;
+				currentJsRuntimeCandidates = collectWebpackJsRuntimeCandidatesFromAssets({
+					escapeFragments,
+					getAssetSource: getWebpackAssetSource,
+					isWebGeneratorTarget,
+					jsAssets: jsAssets.values()
+				});
+				return currentJsRuntimeCandidates;
+			};
+			const getCurrentJsRuntimeTokenSignature = () => {
+				if (currentJsRuntimeTokenSignature !== void 0) return currentJsRuntimeTokenSignature;
+				currentJsRuntimeTokenSignature = collectWebpackJsRuntimeTokenSignature({
+					getAssetSource: getWebpackAssetSource,
+					isWebGeneratorTarget,
+					jsAssets: jsAssets.values()
+				});
+				return currentJsRuntimeTokenSignature;
+			};
+			const rememberTransformedRuntimeCandidates = (source) => {
+				currentJsRuntimeCandidates = void 0;
+				currentJsRuntimeTokenSignature = void 0;
+				const code = stringifyWebpackSourceLike(source);
+				for (const candidate of collectStrictEscapedRuntimeCandidates(code, MappingChars2String, escapeFragments)) if (isRuntimeTransformCandidate(candidate)) transformedJsRuntimeCandidates.add(candidate);
+			};
+			const createRuntimeSetHash = (generatorRuntimeSet) => compilerOptions.cache.computeHash([
+				getRuntimeClassSetSignature(runtimeState.tailwindRuntime),
+				[...runtimeSet].sort().join("\n"),
+				[...transformRuntimeSet].sort().join("\n"),
+				[...generatorRuntimeSet].sort().join("\n"),
+				getCurrentJsRuntimeTokenSignature()
+			].join("\n\n"));
+			const getGeneratorRuntimeSet = () => {
+				const currentJsCandidates = getCurrentJsRuntimeCandidates();
+				if (transformedJsRuntimeCandidates.size === 0 && (!currentJsCandidates || currentJsCandidates.size === 0)) return generatorRuntimeSet;
+				const nextRuntimeSet = new Set(generatorRuntimeSet);
+				for (const candidate of currentJsCandidates) nextRuntimeSet.add(candidate);
+				for (const candidate of transformedJsRuntimeCandidates) nextRuntimeSet.add(candidate);
+				return nextRuntimeSet;
+			};
+			const defaultTemplateHandlerOptions = { runtimeSet: transformRuntimeSet };
+			debug("get runtimeSet, class count: %d, transform class count: %d", runtimeSet.size, transformRuntimeSet.size);
+			const tasks = [];
+			const htmlTaskFactories = [];
+			const cssTaskFactories = [];
+			const enqueueTask = async (factory, target) => {
+				if (watchMode) {
+					await factory();
+					return;
+				}
+				target.push(factory);
+			};
+			if (!isWebGeneratorTarget && Array.isArray(groupedEntries.html)) for (const element of groupedEntries.html) {
+				const [file, originalSource] = element;
+				let rawSource;
+				const readRawSource = () => {
+					rawSource ?? (rawSource = originalSource.source().toString());
+					return rawSource;
+				};
+				const cacheKey = file;
+				const hashKey = `${file}:asset`;
+				rememberProcessCacheKey(cacheKey, hashKey);
+				const chunkHash = assetHashByChunk.get(file);
+				await enqueueTask(async () => {
+					await processCachedTask({
+						cache: compilerOptions.cache,
+						cacheKey,
+						hashKey,
+						rawSource: chunkHash === void 0 ? readRawSource() : void 0,
+						hash: chunkHash,
+						applyResult(source, { cacheHit }) {
+							updateAssetIfChanged(file, source, {
+								compare: !cacheHit,
+								notifyUpdate: !cacheHit
+							});
+						},
+						onCacheHit() {
+							debug("html cache hit: %s", file);
+						},
+						transform: async () => {
+							const source = new ConcatSource(await compilerOptions.templateHandler(readRawSource(), defaultTemplateHandlerOptions));
+							debug("html handle: %s", file);
+							return { result: source };
+						}
+					});
+				}, htmlTaskFactories);
+			}
+			const jsTaskFactories = [];
+			const enqueueJsTask = async (factory) => {
+				await enqueueTask(factory, jsTaskFactories);
+			};
+			if (!isWebGeneratorTarget && Array.isArray(groupedEntries.js)) for (const [file] of groupedEntries.js) {
+				const cacheKey = getCacheKey(file);
+				const asset = compilation.getAsset(file);
+				if (!asset) continue;
+				const hashKey = `${file}:asset`;
+				rememberProcessCacheKey(cacheKey, hashKey);
+				const absoluteFile = toAbsoluteOutputPath(file, outputDir);
+				const initialSource = asset.source.source();
+				const initialRawSource = typeof initialSource === "string" ? initialSource : initialSource.toString();
+				const chunkHash = assetHashByChunk.get(file);
+				await enqueueJsTask(async () => {
+					await processCachedTask({
+						cache: compilerOptions.cache,
+						cacheKey,
+						hashKey,
+						rawSource: chunkHash === void 0 ? initialRawSource : void 0,
+						hash: chunkHash,
+						applyResult(source, { cacheHit }) {
+							if (updateAssetIfChanged(file, source, {
+								compare: !cacheHit,
+								notifyUpdate: !cacheHit
+							})) rememberTransformedRuntimeCandidates(source);
+						},
+						onCacheHit() {
+							debug("js cache hit: %s", file);
+						},
+						transform: async () => {
+							const currentSourceValue = compilation.getAsset(file)?.source.source();
+							const currentSource = stringifyOptionalWebpackSourceValue(currentSourceValue);
+							const handlerOptions = {
+								tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+								generateMap: false,
+								filename: absoluteFile,
+								moduleGraph: moduleGraphOptions,
+								babelParserOptions: { sourceFilename: absoluteFile }
+							};
+							if (shouldSkipJsTransform(currentSource, {
+								...handlerOptions,
+								classNameSet: transformRuntimeSet
+							})) return { result: new ConcatSource(currentSource) };
+							const { code, linked } = await compilerOptions.jsHandler(currentSource, transformRuntimeSet, handlerOptions);
+							const source = new ConcatSource(code);
+							debug("js handle: %s", file);
+							applyWebpackLinkedJsResults({
+								ConcatSource,
+								compilation,
+								compilerOptions,
+								debug,
+								jsAssets,
+								linked
+							});
+							return { result: source };
+						}
+					});
+				});
+			}
+			for (const element of groupedEntries.css) {
+				const [file, originalSource] = element;
+				let rawSource;
+				const readRawSource = () => {
+					rawSource ?? (rawSource = originalSource.source().toString());
+					return rawSource;
+				};
+				const chunkHash = assetHashByChunk.get(file);
+				const cssHandlerOptionsForProcessedAsset = getCssHandlerOptions(file);
+				const processedCssAssetMetadata = { isMainCssChunk: cssHandlerOptionsForProcessedAsset.isMainChunk };
+				const processedSourceFile = cssHandlerOptionsForProcessedAsset.sourceOptions?.sourceFile;
+				const processedSourceCss = processedSourceFile ? cssSources.get(path.resolve(processedSourceFile))?.css : void 0;
+				const shouldRegenerateProcessedTailwindV4SourceCss = processedSourceCss !== void 0 && (hasTailwindSourceDirectives(processedSourceCss, { importFallback: true }) || processedSourceCss.includes("@config"));
+				const processedCssAssetKnown = isKnownWebpackProcessedCssAsset?.(file, processedCssAssetMetadata) === true;
+				const processedLoaderGeneratedCss = processedSourceFile ? generatedCssSources.get(path.resolve(processedSourceFile)) : void 0;
+				const processedAssetSourceHash = watchMode && isWebGeneratorTarget && cssHandlerOptionsForProcessedAsset.isMainChunk ? compilerOptions.cache.computeHash(readRawSource()) : chunkHash === void 0 ? processedCssAssetKnown ? "webpack-css-asset:known" : compilerOptions.cache.computeHash(readRawSource()) : "webpack-css-asset:chunk";
+				const processedCssDecisionCacheKey = `${file}:${createRuntimeAwareCssHash(chunkHash, processedAssetSourceHash, `${createRuntimeSetHash(getGeneratorRuntimeSet())}:${runtimeAffectingSourceHash}:${webpackSourceCandidates?.signatureHash ?? "source-candidates:0"}:${webpackSourceCandidateValueSignature}:${cssSourceTraceSignature}`)}`;
+				let currentProcessedRawSource;
+				let hasGeneratedCssMarker = false;
+				let hasTailwindGeneratedAssetCss = false;
+				const readCurrentProcessedRawSource = () => {
+					currentProcessedRawSource ?? (currentProcessedRawSource = readRawSource());
+					return currentProcessedRawSource;
+				};
+				const cachedSkipProcessedCssAsset = processedCssAssetKnown ? processedCssAssetSkipDecisionCache.get(processedCssDecisionCacheKey) : void 0;
+				const shouldRegenerateStaleProcessedWebCssAsset = isWebGeneratorTarget && !processedCssAssetKnown && cachedSkipProcessedCssAsset === void 0 && cssHandlerOptionsForProcessedAsset.isMainChunk && webpackSourceCandidateSet !== void 0 && (hasMissingRuntimeCandidates(processedLoaderGeneratedCss?.classSet, webpackSourceCandidateSet) || hasMissingRuntimeCandidates(resolveGeneratedCssRuntimeCandidates(readCurrentProcessedRawSource(), processedLoaderGeneratedCss?.classSet), webpackSourceCandidateSet));
+				if (cachedSkipProcessedCssAsset !== void 0) {
+					hasGeneratedCssMarker = cachedSkipProcessedCssAsset && cssHandlerOptionsForProcessedAsset.isMainChunk;
+					hasTailwindGeneratedAssetCss = hasGeneratedCssMarker;
+				} else {
+					const source = readCurrentProcessedRawSource();
+					hasGeneratedCssMarker = hasBundlerGeneratedCssMarker(source);
+					hasTailwindGeneratedAssetCss = hasTailwindGeneratedCss(source) || hasTailwindGeneratedCssMarkers(source);
+				}
+				const hasProcessedAssetTailwindDirectives = () => {
+					const source = readCurrentProcessedRawSource();
+					return hasTailwindRootDirectives(source, { importFallback: true }) || hasTailwindSourceDirectives(source, { importFallback: true }) || hasTailwindApplyDirective(source);
+				};
+				const shouldForceConfiguredMainCssGeneration = cssHandlerOptionsForProcessedAsset.isMainChunk && hasConfiguredTailwindV4SourceRoots() && !hasGeneratedCssMarker && (configuredMainCssEntryFiles.length > 0 || shouldRegenerateProcessedTailwindV4SourceCss || hasProcessedAssetTailwindDirectives());
+				const hasProcessedMainAssetUserCss = cachedSkipProcessedCssAsset === void 0 && cssHandlerOptionsForProcessedAsset.isMainChunk && (hasGeneratedCssMarker || hasTailwindGeneratedAssetCss) && createWebpackUserCssSourceAppend([...cssSources.entries()].map(([sourceFile, source]) => ({
+					...source,
+					file: sourceFile
+				})), readCurrentProcessedRawSource()) !== void 0;
+				const shouldFinalizeProcessedWebCssAsset = isWebGeneratorTarget && !shouldForceConfiguredMainCssGeneration && !shouldRegenerateProcessedTailwindV4SourceCss && hasTailwindSourceDirectives(readCurrentProcessedRawSource(), { importFallback: true });
+				const shouldPreserveFinalWebCssAsset = isWebGeneratorTarget && processedSourceFile === void 0 && !shouldForceConfiguredMainCssGeneration && (hasGeneratedCssMarker || hasTailwindGeneratedAssetCss);
+				const shouldSkipKnownProcessedCssAsset = !shouldForceConfiguredMainCssGeneration && !shouldRegenerateProcessedTailwindV4SourceCss && !shouldRegenerateStaleProcessedWebCssAsset && (processedCssAssetKnown || isWebpackProcessedCssAsset?.(file, readCurrentProcessedRawSource(), processedCssAssetMetadata)) && !hasProcessedMainAssetUserCss && (!cssHandlerOptionsForProcessedAsset.isMainChunk || hasGeneratedCssMarker || hasTailwindGeneratedAssetCss);
+				const shouldSkipProcessedCssAsset = cachedSkipProcessedCssAsset ?? (shouldFinalizeProcessedWebCssAsset || shouldPreserveFinalWebCssAsset || shouldSkipKnownProcessedCssAsset);
+				if (processedCssAssetKnown && cachedSkipProcessedCssAsset === void 0 && !shouldFinalizeProcessedWebCssAsset && !shouldPreserveFinalWebCssAsset) processedCssAssetSkipDecisionCache.set(processedCssDecisionCacheKey, shouldSkipProcessedCssAsset === true);
+				if (shouldSkipProcessedCssAsset) {
+					const hashKey = `${file}:asset`;
+					const sourceHash = processedAssetSourceHash;
+					rememberProcessCacheKey(file, hashKey);
+					await enqueueTask(async () => {
+						await processCachedTask({
+							cache: compilerOptions.cache,
+							cacheKey: file,
+							hashKey,
+							rawSource: chunkHash === void 0 && !processedCssAssetKnown ? readCurrentProcessedRawSource() : void 0,
+							hash: createRuntimeAwareCssHash(chunkHash, sourceHash, `${createRuntimeSetHash(getGeneratorRuntimeSet())}:${runtimeAffectingSourceHash}:${webpackSourceCandidates?.signatureHash ?? "source-candidates:0"}:${webpackSourceCandidateValueSignature}:${cssSourceTraceSignature}`),
+							applyResult(source, { cacheHit }) {
+								updateAssetIfChanged(file, source, {
+									compare: !cacheHit,
+									notifyUpdate: !cacheHit
+								});
+							},
+							onCacheHit() {
+								debug("css webpack-loader-pipeline cache hit: %s", file);
+							},
+							transform: async () => {
+								const source = readCurrentProcessedRawSource();
+								const nextCss = stripTrailingLineWhitespace(finalizeCssAssetSource(hasTailwindGeneratedAssetCss && !hasGeneratedCssMarker ? isWebGeneratorTarget ? source : (await compilerOptions.styleHandler(source, cssHandlerOptionsForProcessedAsset)).css : source, { generatedCss: hasGeneratedCssMarker || hasTailwindGeneratedAssetCss }));
+								debug("css skip webpack-loader-pipeline asset: %s", file);
+								return { result: new ConcatSource(finalizeTracedCss(nextCss, cssHandlerOptionsForProcessedAsset)) };
+							}
+						});
+					}, cssTaskFactories);
+					continue;
+				}
+				const currentRawSource = readRawSource();
+				if (isWebpackCssLoaderRuntimeSource(currentRawSource)) {
+					const hashKey = `${file}:asset`;
+					rememberProcessCacheKey(file, hashKey);
+					await enqueueTask(async () => {
+						await processCachedTask({
+							cache: compilerOptions.cache,
+							cacheKey: file,
+							hashKey,
+							rawSource: currentRawSource,
+							hash: createRuntimeAwareCssHash(chunkHash, compilerOptions.cache.computeHash(currentRawSource), "webpack-css-loader-runtime"),
+							applyResult(source, { cacheHit }) {
+								updateAssetIfChanged(file, source, {
+									compare: !cacheHit,
+									notifyUpdate: !cacheHit
+								});
+							},
+							onCacheHit() {
+								debug("css-loader runtime cache hit: %s", file);
+							},
+							transform: async () => ({ result: new ConcatSource(currentRawSource) })
+						});
+					}, cssTaskFactories);
+					continue;
+				}
+				const cacheKey = file;
+				const hashKey = `${file}:asset`;
+				rememberProcessCacheKey(cacheKey, hashKey);
+				const cssHandlerOptionsForHash = getCssHandlerOptions(file, currentRawSource);
+				const cssChunkHash = watchMode && cssHandlerOptionsForHash.isMainChunk ? void 0 : chunkHash;
+				const cssSourceHash = (() => {
+					const sourceFile = resolveWebpackCssSourceFile(file, currentRawSource);
+					const sourceCss = sourceFile ? cssSources.get(sourceFile)?.css : void 0;
+					const generatorSourceCss = removeWebpackGeneratorNonTailwindImports(sourceCss);
+					if (sourceCss === void 0) return sourceFile === void 0 ? "webpack-css-source:0" : `webpack-css-source:0:${sourceFile}`;
+					return `webpack-css-source:1:${compilerOptions.cache.computeHash(sourceCss)}:${generatorSourceCss === sourceCss || generatorSourceCss === void 0 ? "generator-source:0" : compilerOptions.cache.computeHash(generatorSourceCss)}`;
+				})();
+				const runtimeAwareHash = createRuntimeAwareCssHash(cssChunkHash, compilerOptions.cache.computeHash(currentRawSource), `${createRuntimeSetHash(getGeneratorRuntimeSet())}:${runtimeAffectingSourceHash}:${webpackSourceCandidates?.signatureHash ?? "source-candidates:0"}:${webpackSourceCandidateValueSignature}:${cssSourceTraceSignature}:${cssSourceHash}`);
+				await enqueueTask(async () => {
+					await processCachedTask({
+						cache: compilerOptions.cache,
+						cacheKey,
+						hashKey,
+						rawSource: currentRawSource,
+						hash: runtimeAwareHash,
+						applyResult(source, { cacheHit }) {
+							updateAssetIfChanged(file, source, {
+								compare: !cacheHit,
+								notifyUpdate: !cacheHit
+							});
+						},
+						onCacheHit() {
+							debug("css cache hit: %s", file);
+						},
+						transform: async () => {
+							await runtimeState.readyPromise;
+							const cssHandlerOptions = getCssHandlerOptions(file, currentRawSource);
+							const generatorRawSource = resolveWebpackGeneratorRawSource(currentRawSource, cssHandlerOptions);
+							if (isWebpackCssLoaderRuntimeSource(generatorRawSource)) return { result: new ConcatSource(currentRawSource) };
+							const sourceFile = cssHandlerOptions.sourceOptions?.sourceFile;
+							const loaderGeneratedCss = sourceFile && !isWebGeneratorTarget ? generatedCssSources.get(path.resolve(sourceFile)) : void 0;
+							const sourceCss = sourceFile ? cssSources.get(path.resolve(sourceFile))?.css : void 0;
+							const shouldRegenerateExplicitTailwindV4CssSource = sourceCss !== void 0 && (hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || sourceCss.includes("@config"));
+							if (loaderGeneratedCss && (!shouldRegenerateExplicitTailwindV4CssSource || hasBundlerGeneratedCssMarker(currentRawSource))) {
+								for (const className of loaderGeneratedCss.classSet) {
+									generatorRuntimeSet.add(className);
+									transformRuntimeSet.add(className);
+								}
+								for (const dependency of loaderGeneratedCss.dependencies) compilation.fileDependencies?.add?.(dependency);
+								const currentRawSourceWithoutBundlerMarkers = stripBundlerGeneratedCssMarkers(currentRawSource);
+								const currentAssetHasProcessedUrl = hasProcessedCssAssetUrl(currentRawSourceWithoutBundlerMarkers) && currentRawSourceWithoutBundlerMarkers !== loaderGeneratedCss.css;
+								const currentAssetUserCss = currentAssetHasProcessedUrl ? currentRawSourceWithoutBundlerMarkers : shouldUseWebpackAssetAsGeneratorUserCss(currentRawSourceWithoutBundlerMarkers, loaderGeneratedCss.css, { processed: true }) ? removeGeneratedSelectorCompatCss(currentRawSourceWithoutBundlerMarkers, loaderGeneratedCss.css) : void 0;
+								const css = finalizeTracedCss(finalizeCssAssetSource(currentAssetUserCss === void 0 ? loaderGeneratedCss.css : createWebpackGeneratorUserCssSourceAppend({
+									css: currentAssetHasProcessedUrl ? removeGeneratedSelectorCompatCss(loaderGeneratedCss.css, currentAssetUserCss) : filterExistingCssRules(currentAssetUserCss, loaderGeneratedCss.css),
+									processed: true
+								}, {
+									css: currentAssetUserCss,
+									processed: true
+								}).css, { generatedCss: true }), cssHandlerOptions);
+								debug("css consume webpack loader generation: %s <- %s", file, sourceFile);
+								return { result: new ConcatSource(css) };
+							}
+							const sourceCssProcessed = sourceFile ? cssSources.get(path.resolve(sourceFile))?.processed === true : false;
+							const registeredUserRawSource = createWebpackUserCssSourceAppend([...cssSources.entries()].map(([registeredSourceFile, source]) => ({
+								...source,
+								file: registeredSourceFile
+							})), generatorRawSource, sourceFile, (registeredSourceFile) => isSameWebpackSourceScope(file, registeredSourceFile, sourceFile));
+							const currentAssetLooksGenerated = hasTailwindGeneratedCss(currentRawSource) || hasTailwindGeneratedCssMarkers(currentRawSource);
+							const currentAssetHasBundlerGeneratedMarker = hasBundlerGeneratedCssMarker(currentRawSource);
+							const currentAssetUserCssSource = currentAssetLooksGenerated ? removeWebpackTailwindGeneratedAssetCss(currentRawSource) : currentRawSource;
+							const currentAssetHasAdditionalUserCss = currentAssetLooksGenerated && (hasAdditionalWebpackAssetUserCssMarkers(currentAssetUserCssSource, generatorRawSource) || currentAssetUserCssSource.trim().length > 0);
+							const shouldPreserveGeneratedWebAssetUserCss = isWebGeneratorTarget && currentAssetLooksGenerated && !currentAssetHasBundlerGeneratedMarker && !currentAssetHasAdditionalUserCss;
+							const hasExplicitSourceCssForCurrentAsset = sourceCss !== void 0 && (hasTailwindRootDirectives(sourceCss, { importFallback: true }) || hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || hasTailwindApplyDirective(sourceCss));
+							const currentAssetHasUserCss = (sourceCssProcessed || hasExplicitSourceCssForCurrentAsset) && currentAssetLooksGenerated && !shouldPreserveGeneratedWebAssetUserCss ? currentAssetHasAdditionalUserCss : shouldUseWebpackAssetAsGeneratorUserCss(currentAssetUserCssSource, generatorRawSource, { processed: sourceCssProcessed || shouldPreserveGeneratedWebAssetUserCss });
+							const userRawSource = createWebpackGeneratorUserCssSourceAppend(createWebpackCurrentAssetUserRawSource({
+								currentAssetHasUserCss,
+								currentAssetLooksGenerated,
+								currentAssetUserCssSource,
+								shouldAppendCurrentAssetUserCss: shouldAppendCurrentWebpackAssetUserCss({
+									currentAssetHasBundlerGeneratedMarker,
+									currentAssetHasUserCss,
+									currentAssetLooksGenerated,
+									registeredUserRawSource,
+									shouldPreserveGeneratedWebAssetUserCss,
+									sourceCssProcessed
+								}),
+								sourceCssProcessed
+							}), registeredUserRawSource);
+							if (isPureLocalCssImportWrapper(currentRawSource)) return { result: new ConcatSource(removeTailwindSourceDirectives(stripBundlerGeneratedCssMarkers(currentRawSource), { importFallback: true })) };
+							const fallbackGeneratorRuntimeSet = getGeneratorRuntimeSet();
+							const hasExplicitTailwindV4SourceCss = sourceCss !== void 0 && (hasTailwindSourceDirectives(sourceCss, { importFallback: true }) || sourceCss.includes("@config"));
+							const shouldForceTailwindV4Generation = cssHandlerOptions.isMainChunk && hasConfiguredTailwindV4SourceRoots() && (configuredMainCssEntryFiles.length > 0 || hasTailwindRootDirectives(generatorRawSource, { importFallback: true }) || hasTailwindSourceDirectives(generatorRawSource, { importFallback: true }) || hasTailwindApplyDirective(generatorRawSource) || hasExplicitTailwindV4SourceCss);
+							const resolvedScopedGeneratorRuntimeSet = await createScopedGeneratorRuntime({
+								cssHandlerOptions,
+								fallbackRuntime: hasExplicitTailwindV4SourceCss ? /* @__PURE__ */ new Set() : fallbackGeneratorRuntimeSet,
+								getSourceCandidatesForEntries: webpackSourceCandidates?.getSourceCandidatesForEntries,
+								majorVersion: runtimeState.tailwindRuntime.majorVersion,
+								outputFile: file,
+								rawSource: sourceFile ? cssSources.get(path.resolve(sourceFile))?.css ?? generatorRawSource : generatorRawSource,
+								shouldExcludeSubpackageSourceCandidates: () => false,
+								sourceFile: sourceFile ?? file,
+								scopedSourceCandidateGetter: webpackSourceCandidates?.getSourceCandidatesForEntries
+							});
+							const scopedGeneratorRuntimeSet = !hasExplicitTailwindV4SourceCss && resolvedScopedGeneratorRuntimeSet !== fallbackGeneratorRuntimeSet ? new Set([...fallbackGeneratorRuntimeSet, ...resolvedScopedGeneratorRuntimeSet]) : resolvedScopedGeneratorRuntimeSet;
+							const generatorCssSources = normalizeWebpackGeneratorCssSources(cssHandlerOptions.sourceOptions?.cssSources);
+							const generatorCssHandlerOptions = generatorCssSources === void 0 ? cssHandlerOptions : {
+								...cssHandlerOptions,
+								sourceOptions: {
+									...cssHandlerOptions.sourceOptions,
+									cssSources: generatorCssSources
+								}
+							};
+							const generatorOptions = {
+								opts: compilerOptions,
+								runtimeState,
+								runtime: scopedGeneratorRuntimeSet,
+								rawSource: generatorRawSource,
+								forceGenerator: shouldForceTailwindV4Generation,
+								...hasUsableWebpackGeneratorCssSources(generatorCssSources) ? { cssSources: generatorCssSources } : {},
+								...userRawSource === void 0 ? {} : { userRawSource: userRawSource.css },
+								...userRawSource?.processed === true ? { userRawSourceProcessed: true } : {},
+								file,
+								cssHandlerOptions: generatorCssHandlerOptions,
+								cssUserHandlerOptions: getCssUserHandlerOptions(file),
+								getSourceCandidatesForEntries: webpackSourceCandidates?.getSourceCandidatesForEntries,
+								sourceCandidates: scopedGeneratorRuntimeSet,
+								restoreLocalCssImports: false,
+								styleHandler: compilerOptions.styleHandler,
+								debug
+							};
+							let generated;
+							try {
+								generated = await generateTailwindV4Css({
+									...generatorOptions,
+									outputFile: file
+								});
+							} catch (error) {
+								if (!shouldFallbackToWebpackUserCssOnGeneratorError({
+									configuredMainCssEntryFilesLength: configuredMainCssEntryFiles.length,
+									generatorRawSource,
+									hasExplicitTailwindV4SourceCss
+								})) throw error;
+								debug("css generator skipped for plain webpack css asset: %s %O", file, error);
+								generated = void 0;
+							}
+							const source = new ConcatSource(finalizeTracedCss(generated ? finalizeCssAssetSource(isWebGeneratorTarget && currentRawSource.includes("tailwindcss v4.") ? createWebpackGeneratorUserCssSourceAppend({
+								css: generated.css,
+								processed: true
+							}, {
+								css: removeWebpackTailwindGeneratedAssetCss(currentRawSource),
+								processed: true
+							})?.css ?? generated.css : generated.css, { generatedCss: true }) : isWebGeneratorTarget ? finalizeCssAssetSource(generatorRawSource, { generatedCss: false }) : finalizeCssAssetSource((await compilerOptions.styleHandler(generatorRawSource, cssHandlerOptions)).css, { generatedCss: false }), cssHandlerOptions));
+							if (generated) {
+								for (const className of generated.classSet) generatorRuntimeSet.add(className);
+								debug("css handle via tailwind v%s engine(%s): %s", runtimeState.tailwindRuntime.majorVersion, generated.target, file);
+							} else debug("css handle: %s", file);
+							return { result: source };
+						}
+					});
+				}, cssTaskFactories);
+			}
+			if (!watchMode) {
+				pushConcurrentTaskFactories(tasks, htmlTaskFactories, taskConcurrency);
+				await Promise.all(tasks);
+				tasks.length = 0;
+				pushConcurrentTaskFactories(tasks, jsTaskFactories, taskConcurrency);
+				await Promise.all(tasks);
+				tasks.length = 0;
+				pushConcurrentTaskFactories(tasks, cssTaskFactories, taskConcurrency);
+			}
+			await Promise.all(tasks);
+			compilerOptions.cache.prune?.({
+				cacheKeys: activeProcessCacheKeys,
+				hashKeys: activeProcessHashKeys
+			});
+			const activeCssFiles = new Set(groupedEntries.css.map(([file]) => file));
+			pruneWebpackCssHandlerOptionCaches(cssHandlerOptionsCache, cssUserHandlerOptionsCache, activeCssFiles);
+			if (activeCssFiles.size > 0) pruneWebpackCssSources?.(new Set([
+				...registeredWebpackCssSourceFiles,
+				...activeWebpackCssSourceFiles,
+				...[...cssAssetResources.values()].flatMap((resources) => [...resources])
+			]), { watchMode });
+			debug("end");
+			emitHmrTiming("webpack", "processAssets", performance.now() - hmrTimingStartedAt, { memoryDebug: resolveWebpackMemoryDebugStats({
+				activeAssetFiles: entries.length,
+				activeCssFiles: activeCssFiles.size,
+				activeProcessCacheKeys,
+				activeProcessHashKeys,
+				cache: compilerOptions.cache,
+				cssHandlerOptionsCache,
+				cssUserHandlerOptionsCache,
+				phase: "processAssets",
+				sourceCandidateScan: webpackSourceCandidateScanCache.getMemoryStats()
+			}) });
+			compilerOptions.onEnd();
+		});
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.22.2_oxc-resolver@11.20.0_tsx@4.22.4_typescript@6.0.3_unrun@0.2.37_synckit@0.1_c2142480ddc0e0584f1991298dd762a0/node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+//#endregion
+//#region src/bundlers/webpack/loaders/runtime-registry.ts
+const runtimeRegistryHolder = globalThis;
+const runtimeRegistry = runtimeRegistryHolder.__WEAPP_TW_WEBPACK_LOADER_RUNTIME_REGISTRY__ ?? (runtimeRegistryHolder.__WEAPP_TW_WEBPACK_LOADER_RUNTIME_REGISTRY__ = /* @__PURE__ */ new Map());
+function setWebpackLoaderRuntime(key, entry) {
+	runtimeRegistry.set(key, entry);
+}
+function deleteWebpackLoaderRuntime(key) {
+	runtimeRegistry.delete(key);
+}
+//#endregion
+//#region src/bundlers/webpack/shared/loader-anchors.ts
+const MPX_STRIP_CONDITIONAL_LOADER = "@mpxjs/webpack-plugin/lib/style-compiler/strip-conditional-loader";
+const MPX_STYLE_COMPILER_LOADER = "@mpxjs/webpack-plugin/lib/style-compiler/index";
+const MPX_REWRITE_PRECEDENCE_LOADERS = [MPX_STYLE_COMPILER_LOADER, MPX_STRIP_CONDITIONAL_LOADER];
+function createFinder(targets) {
+	return (entries) => entries.findIndex((entry) => targets.some((target) => entry?.loader?.includes?.(target)));
+}
+function createPrioritizedFinder(targets) {
+	return (entries) => {
+		for (const target of targets) {
+			const idx = entries.findIndex((entry) => entry?.loader?.includes?.(target));
+			if (idx !== -1) return idx;
+		}
+		return -1;
+	};
+}
+function createLoaderAnchorFinders(appType) {
+	if (isMpx(appType)) return {
+		findRewriteAnchor: createPrioritizedFinder(MPX_REWRITE_PRECEDENCE_LOADERS),
+		findClassSetAnchor: createFinder([MPX_STYLE_COMPILER_LOADER])
+	};
+	const fallbackFinder = createFinder(["postcss-loader"]);
+	return {
+		findRewriteAnchor: fallbackFinder,
+		findClassSetAnchor: fallbackFinder
+	};
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5-loaders.ts
+function setupWebpackV5Loaders(options) {
+	const { compiler, options: compilerOptions, appType, weappTailwindcssPackageDir, shouldRewriteCssImports, runtimeLoaderPath, registerAutoCssSource, runtimeState, getClassSetInLoader, getRuntimeSetInLoader, markWebpackProcessedCssSource, markWebpackCssSourceModule, registerWebpackGeneratedCss, registerWebpackCssSourceFile, getRuntimeWatchDependencies, runtimeRegistryKey = `weapp-tailwindcss-${Date.now()}-${Math.random().toString(36).slice(2)}`, debug } = options;
+	const isMpxApp = isMpx(appType);
+	const generatorTarget = compilerOptions.generator?.target ?? inferGeneratorTargetFromEnv();
+	const generatorBranch = resolveRuntimeBranch({
+		appType: compilerOptions.appType,
+		generatorTarget,
+		platform: compilerOptions.cssOptions?.platform ?? compilerOptions.platform,
+		tailwindcssMajorVersion: runtimeState.tailwindRuntime.majorVersion,
+		uniAppX: compilerOptions.uniAppX
+	});
+	if (shouldRewriteCssImports && isMpxApp) ensureMpxTailwindcssAliases(compiler, weappTailwindcssPackageDir);
+	const runtimeClassSetLoader = runtimeLoaderPath ?? path.resolve(__dirname, "./weapp-tw-runtime-classset-loader.js");
+	const shouldInjectRuntimeClassSetLoader = !generatorBranch.isWeb;
+	const shouldInjectCssImportRewriteLoader = shouldRewriteCssImports || !generatorBranch.isWeb || runtimeState.tailwindRuntime.majorVersion === 4;
+	const runtimeCssImportRewriteLoader = shouldInjectCssImportRewriteLoader ? path.resolve(__dirname, "./weapp-tw-css-import-rewrite-loader.js") : void 0;
+	const runtimeClassSetLoaderExists = fs.existsSync(runtimeClassSetLoader);
+	const runtimeCssImportRewriteLoaderExists = runtimeCssImportRewriteLoader ? fs.existsSync(runtimeCssImportRewriteLoader) : false;
+	const runtimeLoaderRewriteOptions = shouldInjectCssImportRewriteLoader ? {
+		pkgDir: weappTailwindcssPackageDir,
+		compilerOptions,
+		runtimeState,
+		...appType === void 0 ? {} : { appType },
+		...registerAutoCssSource === void 0 ? {} : { registerCssSource: registerAutoCssSource },
+		...registerWebpackCssSourceFile === void 0 ? {} : { registerCssSourceFile: registerWebpackCssSourceFile },
+		getRuntimeSet: getRuntimeSetInLoader,
+		...markWebpackProcessedCssSource === void 0 ? {} : { markGeneratedCssSource: markWebpackProcessedCssSource },
+		...registerWebpackGeneratedCss === void 0 ? {} : { registerGeneratedCss: registerWebpackGeneratedCss }
+	} : void 0;
+	setWebpackLoaderRuntime(runtimeRegistryKey, {
+		classSet: {
+			getClassSet: getClassSetInLoader,
+			getWatchDependencies: getRuntimeWatchDependencies,
+			...registerWebpackCssSourceFile === void 0 ? {} : { registerCssSourceFile: registerWebpackCssSourceFile }
+		},
+		...runtimeLoaderRewriteOptions === void 0 ? {} : { cssImportRewrite: runtimeLoaderRewriteOptions }
+	});
+	const cleanupWebpackLoaderRuntime = () => {
+		deleteWebpackLoaderRuntime(runtimeRegistryKey);
+	};
+	compiler.hooks.watchClose?.tap?.(pluginName, cleanupWebpackLoaderRuntime);
+	compiler.hooks.shutdown?.tap?.(pluginName, cleanupWebpackLoaderRuntime);
+	const { findRewriteAnchor, findClassSetAnchor } = createLoaderAnchorFinders(appType);
+	const cssImportRewriteLoaderOptions = runtimeLoaderRewriteOptions ? { tailwindcssImportRewriteRuntimeKey: runtimeRegistryKey } : void 0;
+	if (runtimeCssImportRewriteLoader && shouldRewriteCssImports && cssImportRewriteLoaderOptions && isMpxApp) injectMpxCssRewritePreRules(compiler, runtimeCssImportRewriteLoader, cssImportRewriteLoaderOptions);
+	const createRuntimeClassSetLoaderEntry = () => ({
+		loader: runtimeClassSetLoader,
+		options: { weappTailwindcssRuntimeKey: runtimeRegistryKey },
+		ident: null,
+		type: null
+	});
+	const createCssImportRewriteLoaderEntry = () => {
+		if (!runtimeCssImportRewriteLoader || !cssImportRewriteLoaderOptions) return null;
+		return {
+			loader: runtimeCssImportRewriteLoader,
+			options: cssImportRewriteLoaderOptions,
+			ident: null,
+			type: null
+		};
+	};
+	const { NormalModule } = compiler.webpack;
+	compiler.hooks.compilation.tap(pluginName, (compilation) => {
+		NormalModule.getCompilationHooks(compilation).loader.tap(pluginName, (_loaderContext, module) => {
+			if (!(runtimeClassSetLoaderExists || runtimeCssImportRewriteLoaderExists)) return;
+			patchMpxLoaderResolve(_loaderContext, weappTailwindcssPackageDir, shouldRewriteCssImports && isMpxApp);
+			const loaderEntries = module.loaders || [];
+			let rewriteAnchorIdx = findRewriteAnchor(loaderEntries);
+			const classSetAnchorIdx = findClassSetAnchor(loaderEntries);
+			const isCssModule = isCssLikeModuleResource(module.resource, compilerOptions.cssMatcher, appType);
+			if (isCssModule && typeof module.resource === "string") markWebpackCssSourceModule?.(module.resource);
+			if (process.env["WEAPP_TW_LOADER_DEBUG"] && isCssModule) debug("loader hook css module: %s loaders=%o anchors=%o", module.resource, loaderEntries.map((x) => x.loader), {
+				rewriteAnchorIdx,
+				classSetAnchorIdx
+			});
+			if (process.env["WEAPP_TW_LOADER_DEBUG"] && typeof module.resource === "string" && module.resource.endsWith(".css")) debug("css module seen: %s loaders=%o anchors=%o", module.resource, loaderEntries.map((x) => x.loader), {
+				rewriteAnchorIdx,
+				classSetAnchorIdx
+			});
+			if (rewriteAnchorIdx === -1 && classSetAnchorIdx === -1 && !isCssModule) return;
+			const anchorlessInsert = (entry, position) => {
+				if (position === "after") loaderEntries.push(entry);
+				else loaderEntries.unshift(entry);
+			};
+			if (cssImportRewriteLoaderOptions && runtimeCssImportRewriteLoaderExists && runtimeCssImportRewriteLoader && isCssModule) {
+				const existingIndex = loaderEntries.findIndex((entry) => entry.loader?.includes?.(runtimeCssImportRewriteLoader));
+				const rewriteLoaderEntry = existingIndex !== -1 ? loaderEntries.splice(existingIndex, 1)[0] : createCssImportRewriteLoaderEntry();
+				if (rewriteLoaderEntry) {
+					const anchorIndex = findRewriteAnchor(loaderEntries);
+					if (anchorIndex === -1) anchorlessInsert(rewriteLoaderEntry, "after");
+					else loaderEntries.splice(anchorIndex + 1, 0, rewriteLoaderEntry);
+					rewriteAnchorIdx = findRewriteAnchor(loaderEntries);
+				}
+			}
+			if (shouldInjectRuntimeClassSetLoader && runtimeClassSetLoaderExists && !hasLoaderEntry(loaderEntries, runtimeClassSetLoader)) {
+				const classSetLoaderEntry = createRuntimeClassSetLoaderEntry();
+				const anchorIndex = findClassSetAnchor(loaderEntries);
+				if (anchorIndex === -1) anchorlessInsert(classSetLoaderEntry, "before");
+				else {
+					const insertIndex = anchorIndex === -1 ? rewriteAnchorIdx : anchorIndex;
+					loaderEntries.splice(insertIndex, 0, classSetLoaderEntry);
+				}
+			}
+		});
+	});
+}
+//#endregion
+//#region src/bundlers/webpack/BaseUnifiedPlugin/v5.ts
+const debug = createDebug();
+const weappTailwindcssPackageDir = resolvePackageDir("weapp-tailwindcss");
+const outputIgnoredPredicatePath = Symbol("weapp-tailwindcss.outputIgnoredPredicatePath");
+function normalizeIgnoredList(ignored) {
+	return (Array.isArray(ignored) ? [...ignored] : [ignored]).filter((item) => typeof item === "string" || item instanceof RegExp || typeof item === "function");
+}
+function createOutputIgnoredPredicate(ignoredList, ignoredPath) {
+	const predicate = (file) => {
+		const resolvedFile = path.resolve(file);
+		if (resolvedFile === ignoredPath || resolvedFile.startsWith(`${ignoredPath}${path.sep}`)) return true;
+		const normalizedFile = file.replace(/\\/g, "/");
+		return ignoredList.some((item) => {
+			if (typeof item === "string") {
+				const resolvedItem = path.resolve(item);
+				if (resolvedFile === resolvedItem || resolvedFile.startsWith(`${resolvedItem}${path.sep}`)) return true;
+				return micromatch.isMatch(normalizedFile, item);
+			}
+			if (item instanceof RegExp) return item.test(normalizedFile);
+			return item(file);
+		});
+	};
+	predicate[outputIgnoredPredicatePath] = ignoredPath;
+	return predicate;
+}
+function appendIgnoredPath(ignored, ignoredPath) {
+	if (typeof ignored === "function" && ignored[outputIgnoredPredicatePath] === ignoredPath) return ignored;
+	const ignoredList = normalizeIgnoredList(ignored);
+	if (ignoredList.some((item) => typeof item !== "string")) return createOutputIgnoredPredicate(ignoredList, ignoredPath);
+	if (ignoredList.some((item) => typeof item === "string" && path.resolve(item) === ignoredPath)) return ignored;
+	return [...ignoredList, ignoredPath];
+}
+function setupWebpackWatchOutputIgnore(compiler) {
+	const appendOutputIgnoredPath = (watchOptions, outputPath) => {
+		const resolvedOutputPath = outputPath || compiler.outputPath || compiler.options?.output?.path;
+		const outputDir = resolvedOutputPath ? path.resolve(resolvedOutputPath) : void 0;
+		if (!outputDir) return watchOptions;
+		if (watchOptions && typeof watchOptions === "object") {
+			const nextIgnored = appendIgnoredPath(watchOptions.ignored, outputDir);
+			if (nextIgnored === void 0) delete watchOptions.ignored;
+			else watchOptions.ignored = nextIgnored;
+			return watchOptions;
+		}
+		return { ignored: appendIgnoredPath(void 0, outputDir) };
+	};
+	const compilerWatchOptions = appendOutputIgnoredPath(compiler.options.watchOptions);
+	if (compilerWatchOptions) compiler.options.watchOptions = compilerWatchOptions;
+	const syncOutputIgnoredPath = () => {
+		const outputPath = compiler.outputPath || compiler.options?.output?.path;
+		const watchOptions = compiler.watching?.watchOptions;
+		if (watchOptions) appendOutputIgnoredPath(watchOptions, outputPath);
+	};
+	compiler.hooks.watchRun?.tap(pluginName, syncOutputIgnoredPath);
+	compiler.hooks.thisCompilation?.tap(pluginName, (compilation) => {
+		const outputPath = compilation.compiler?.outputPath || compilation.outputOptions?.path;
+		const watchOptions = compiler.watching?.watchOptions;
+		if (watchOptions) appendOutputIgnoredPath(watchOptions, outputPath);
+		else {
+			const compilerWatchOptions = appendOutputIgnoredPath(compiler.options.watchOptions, outputPath);
+			if (compilerWatchOptions) compiler.options.watchOptions = compilerWatchOptions;
+		}
+	});
+}
+/**
+* @name WeappTailwindcss
+* @description webpack5 核心转义插件
+* @link https://tw.icebreaker.top/docs/intro
+*/
+var WeappTailwindcss = class {
+	constructor(options = {}) {
+		_defineProperty(this, "options", void 0);
+		_defineProperty(this, "appType", void 0);
+		_defineProperty(this, "hasInitialTailwindCssRoots", void 0);
+		this.hasInitialTailwindCssRoots = hasConfiguredTailwindV4CssRoots(options);
+		this.options = getCompilerContext({
+			...options,
+			__internalDeferMissingCssEntriesWarning: true
+		});
+		this.appType = this.options.appType;
+	}
+	apply(compiler) {
+		compiler.options = compiler.options || {};
+		const { disabled, onLoad, runtimeLoaderPath, tailwindRuntime, refreshTailwindcssRuntime } = this.options;
+		const initialTailwindRuntime = tailwindRuntime;
+		const refreshTailwindRuntime = refreshTailwindcssRuntime;
+		const disabledOptions = resolvePluginDisabledState(disabled);
+		const shouldRewriteCssImports = this.options.rewriteCssImports === true;
+		const isMpxApp = isMpx(this.appType);
+		if (shouldRewriteCssImports) setupMpxTailwindcssRedirect(weappTailwindcssPackageDir, isMpxApp);
+		if (disabledOptions.plugin) return;
+		if (initialTailwindRuntime.majorVersion !== 4) throw new Error("weapp-tailwindcss/webpack 新生成管线仅支持 Tailwind CSS v4，请升级 tailwindcss 或停留在旧版 weapp-tailwindcss。");
+		setupWebpackWatchOutputIgnore(compiler);
+		const runtimeState = {
+			tailwindRuntime: initialTailwindRuntime,
+			readyPromise: createTailwindRuntimeReadyPromise(initialTailwindRuntime),
+			refreshTailwindcssRuntime: refreshTailwindRuntime
+		};
+		let runtimeSetPrepared = false;
+		let runtimeSetSignature;
+		let runtimeRefreshRequiredForCompilation = false;
+		let watchRunObserved = false;
+		const runtimeWatchDependencyFiles = /* @__PURE__ */ new Set();
+		const runtimeWatchDependencyContexts = /* @__PURE__ */ new Set();
+		const webpackProcessedCssSourceFiles = /* @__PURE__ */ new Set();
+		const webpackCssSources = /* @__PURE__ */ new Map();
+		const webpackGeneratedCssSources = /* @__PURE__ */ new Map();
+		const currentWebpackCssSourceFiles = /* @__PURE__ */ new Set();
+		const currentWebpackCssSourceModules = /* @__PURE__ */ new Set();
+		let runtimeMetadataPrepared = false;
+		const updateRuntimeWatchDependencies = async () => {
+			runtimeWatchDependencyFiles.clear();
+			runtimeWatchDependencyContexts.clear();
+			const tailwindOptions = resolveTailwindcssOptions(runtimeState.tailwindRuntime.options);
+			if (tailwindOptions?.config) runtimeWatchDependencyFiles.add(tailwindOptions.config);
+			for (const entry of tailwindOptions?.v4?.cssEntries ?? []) runtimeWatchDependencyFiles.add(entry);
+			for (const source of tailwindOptions?.v4?.cssSources ?? []) {
+				if (source.file) runtimeWatchDependencyFiles.add(source.file);
+				for (const dependency of source.dependencies ?? []) runtimeWatchDependencyFiles.add(dependency);
+			}
+			for (const source of tailwindOptions?.v4?.sources ?? []) if (source?.base) runtimeWatchDependencyContexts.add(source.base);
+			if (typeof runtimeState.tailwindRuntime.collectContentTokens !== "function") return;
+			try {
+				const report = await runtimeState.tailwindRuntime.collectContentTokens();
+				for (const entry of report.entries ?? []) {
+					const file = typeof entry === "object" && entry !== null && "file" in entry ? entry.file : void 0;
+					if (typeof file === "string") runtimeWatchDependencyFiles.add(file);
+				}
+				for (const source of report.sources ?? []) {
+					const base = typeof source === "object" && source !== null && "base" in source ? source.base : void 0;
+					if (typeof base === "string") runtimeWatchDependencyContexts.add(base);
+				}
+			} catch (error) {
+				debug("collect runtime watch dependencies failed: %O", error);
+			}
+		};
+		const ensureRuntimeMetadata = async (force = false) => {
+			if (runtimeMetadataPrepared && !force) return;
+			await updateRuntimeWatchDependencies();
+			runtimeMetadataPrepared = true;
+		};
+		const collectWatchChangedFiles = () => {
+			const compilerLike = compiler;
+			return new Set([...compilerLike.modifiedFiles ?? [], ...compilerLike.removedFiles ?? []]);
+		};
+		const hasRuntimeDependencyChanges = (files) => {
+			for (const file of files) if (isWatchFileInRuntimeDependencies(file, {
+				contexts: runtimeWatchDependencyContexts,
+				files: runtimeWatchDependencyFiles
+			})) return true;
+			return false;
+		};
+		const syncRuntimeRefreshRequirement = (markWatchRun = false) => {
+			if (markWatchRun) watchRunObserved = true;
+			const changedFiles = collectWatchChangedFiles();
+			runtimeRefreshRequiredForCompilation = runtimeRefreshRequiredForCompilation || hasRuntimeDependencyChanges(changedFiles);
+		};
+		const resetRuntimePreparation = () => {
+			runtimeSetPrepared = false;
+			syncRuntimeRefreshRequirement();
+		};
+		const registerAutoCssSource = async (source) => {
+			if (!source.file) return;
+			if (!upsertTailwindV4CssSource(this.options, source)) return;
+			runtimeSetPrepared = false;
+			runtimeMetadataPrepared = false;
+			runtimeRefreshRequiredForCompilation = true;
+			await refreshTailwindRuntimeState(runtimeState, {
+				force: true,
+				clearCache: true
+			});
+			debug("detected tailwindcss v4 css source from webpack css module: %s", source.file);
+		};
+		const markWebpackProcessedCssSource = (file) => {
+			webpackProcessedCssSourceFiles.add(path.resolve(file));
+		};
+		const markWebpackCssSourceModule = (file) => {
+			currentWebpackCssSourceModules.add(path.resolve(file));
+		};
+		const registerWebpackCssSourceFile = (source) => {
+			const file = path.resolve(source.file);
+			const previous = webpackCssSources.get(file);
+			if (source.processed === true && previous?.processed === false) {
+				currentWebpackCssSourceFiles.add(file);
+				return;
+			}
+			webpackCssSources.set(file, {
+				css: typeof source.css === "string" ? normalizeTailwindConfigDirectives(source.css, path.dirname(file)) : source.css,
+				processed: source.processed
+			});
+			currentWebpackCssSourceFiles.add(file);
+		};
+		const registerWebpackGeneratedCss = (source) => {
+			const file = path.resolve(source.file);
+			webpackGeneratedCssSources.set(file, {
+				...source,
+				file
+			});
+			currentWebpackCssSourceFiles.add(file);
+		};
+		const pruneWebpackCssSources = (activeSourceFiles, _options = {}) => {
+			const tailwindOptions = resolveTailwindcssOptions(runtimeState.tailwindRuntime.options);
+			const configuredSourceFiles = /* @__PURE__ */ new Set();
+			for (const entry of tailwindOptions?.v4?.cssEntries ?? []) configuredSourceFiles.add(path.resolve(entry));
+			for (const source of tailwindOptions?.v4?.cssSources ?? []) if (source.file) configuredSourceFiles.add(path.resolve(source.file));
+			for (const file of webpackCssSources.keys()) if (!activeSourceFiles.has(file) && !configuredSourceFiles.has(file)) webpackCssSources.delete(file);
+			for (const file of webpackGeneratedCssSources.keys()) if (!activeSourceFiles.has(file) && !configuredSourceFiles.has(file)) webpackGeneratedCssSources.delete(file);
+		};
+		const prepareWebpackCssSources = (activeAssetResources = /* @__PURE__ */ new Set()) => {
+			const tailwindOptions = resolveTailwindcssOptions(runtimeState.tailwindRuntime.options);
+			const configuredSourceFiles = /* @__PURE__ */ new Set();
+			for (const entry of tailwindOptions?.v4?.cssEntries ?? []) configuredSourceFiles.add(path.resolve(entry));
+			for (const source of tailwindOptions?.v4?.cssSources ?? []) if (source.file) configuredSourceFiles.add(path.resolve(source.file));
+			const activeSourceFiles = new Set([
+				...configuredSourceFiles,
+				...currentWebpackCssSourceModules,
+				...activeAssetResources,
+				...[...currentWebpackCssSourceFiles].filter((file) => currentWebpackCssSourceModules.has(file)),
+				...[...currentWebpackCssSourceFiles].filter((file) => activeAssetResources.has(file))
+			]);
+			currentWebpackCssSourceFiles.clear();
+			currentWebpackCssSourceModules.clear();
+			return activeSourceFiles;
+		};
+		const isWebpackProcessedTailwindEntryAsset = (isMainCssChunk) => {
+			if (isMainCssChunk !== true || webpackProcessedCssSourceFiles.size === 0) return false;
+			const tailwindOptions = resolveTailwindcssOptions(runtimeState.tailwindRuntime.options);
+			for (const entry of tailwindOptions?.v4?.cssEntries ?? []) if (webpackProcessedCssSourceFiles.has(path.resolve(entry))) return true;
+			for (const source of tailwindOptions?.v4?.cssSources ?? []) if (source.file && webpackProcessedCssSourceFiles.has(path.resolve(source.file))) return true;
+			return false;
+		};
+		compiler.hooks.invalid?.tap?.(pluginName, (fileName) => {
+			if (!fileName) return;
+			runtimeRefreshRequiredForCompilation = runtimeRefreshRequiredForCompilation || hasRuntimeDependencyChanges([path.resolve(fileName)]);
+		});
+		compiler.hooks.watchRun?.tap?.(pluginName, () => syncRuntimeRefreshRequirement(true));
+		if (compiler.hooks.thisCompilation?.tap) compiler.hooks.thisCompilation.tap(pluginName, resetRuntimePreparation);
+		else if (compiler.hooks.compilation?.tap) compiler.hooks.compilation.tap(pluginName, resetRuntimePreparation);
+		async function getClassSetInLoader() {
+			if (runtimeSetPrepared) return;
+			const signature = getRuntimeClassSetSignature(runtimeState.tailwindRuntime);
+			const forceRefresh = runtimeRefreshRequiredForCompilation || signature !== runtimeSetSignature;
+			debug("runtime loader ensure class set forceRefresh=%s watchDirty=%s signatureChanged=%s", forceRefresh, runtimeRefreshRequiredForCompilation, signature !== runtimeSetSignature);
+			runtimeSetPrepared = true;
+			await ensureRuntimeClassSet(runtimeState, {
+				forceRefresh,
+				forceCollect: forceRefresh || !watchRunObserved,
+				clearCache: forceRefresh,
+				allowEmpty: true
+			});
+			await ensureRuntimeMetadata(forceRefresh);
+			runtimeSetSignature = signature;
+			runtimeRefreshRequiredForCompilation = false;
+		}
+		async function getRuntimeSetInLoader() {
+			await getClassSetInLoader();
+			return ensureRuntimeClassSet(runtimeState, { allowEmpty: true });
+		}
+		onLoad();
+		setupWebpackV5Loaders({
+			compiler,
+			options: this.options,
+			appType: this.appType,
+			weappTailwindcssPackageDir,
+			shouldRewriteCssImports,
+			runtimeLoaderPath,
+			registerAutoCssSource,
+			runtimeState,
+			getClassSetInLoader,
+			getRuntimeSetInLoader,
+			markWebpackProcessedCssSource,
+			markWebpackCssSourceModule,
+			registerWebpackCssSourceFile,
+			registerWebpackGeneratedCss,
+			getRuntimeWatchDependencies() {
+				return {
+					files: runtimeWatchDependencyFiles,
+					contexts: runtimeWatchDependencyContexts
+				};
+			},
+			debug
+		});
+		setupWebpackV5ProcessAssetsHook({
+			compiler,
+			options: this.options,
+			appType: this.appType,
+			runtimeState,
+			getRuntimeRefreshRequirement: () => runtimeRefreshRequiredForCompilation,
+			refreshRuntimeMetadata: ensureRuntimeMetadata,
+			isKnownWebpackProcessedCssAsset(file, metadata) {
+				return webpackProcessedCssSourceFiles.has(path.resolve(file)) || isWebpackProcessedTailwindEntryAsset(metadata?.isMainCssChunk);
+			},
+			isWebpackProcessedCssAsset(file, rawSource, metadata) {
+				return webpackProcessedCssSourceFiles.has(path.resolve(file)) || isWebpackProcessedTailwindEntryAsset(metadata?.isMainCssChunk) || hasTailwindGeneratedCss(rawSource) || hasTailwindGeneratedCssMarkers(rawSource) || rawSource.includes("weapp-tailwindcss webpack-generated-css");
+			},
+			consumeRuntimeRefreshRequirement() {
+				runtimeRefreshRequiredForCompilation = false;
+			},
+			isWatchMode: () => watchRunObserved || compiler.options?.watch === true,
+			getWatchChangedFiles: collectWatchChangedFiles,
+			runtimeClassSetManager: this.options.__internalWebpackRuntimeClassSetManager,
+			getWebpackCssSources: () => webpackCssSources,
+			getWebpackGeneratedCssSources: () => webpackGeneratedCssSources,
+			pruneWebpackCssSources,
+			prepareWebpackCssSources,
+			debug
+		});
+	}
+};
+//#endregion
+export { weappTailwindcssPackageDir as n, WeappTailwindcss as t };