weapp-tailwindcss 5.0.0-next.8 → 5.0.0

package/dist/{webpack-CNV2dx3Q.js → webpack-Ccohlg3A.js}

@@ -1,19 +1,21 @@
-const require_chunk = require("./chunk-8l464Juk.js");
-const require_cache = require("./cache-BVAiJV3J.js");
-const require_runtime_patch = require("./runtime-patch-D6mBo_KB.js");
-const require_generator_css = require("./generator-css-Mksw8PgB.js");
-const require_precheck = require("./precheck-B32p-gLI.js");
-const require_utils = require("./utils-BiShvil9.js");
-const require_tailwindcss = require("./tailwindcss-Bu-RWIHx.js");
-const require_run_tasks = require("./run-tasks-B50A3pxt.js");
+const require_chunk = require("./chunk-C5U5_Hdc.js");
+const require_v3_engine = require("./v3-engine-D3BMLVAN.js");
+const require_generator = require("./generator--0-ekuVO.js");
+const require_incremental_runtime_class_set = require("./incremental-runtime-class-set-CN6K_97P.js");
+const require_precheck = require("./precheck-DPtJjZmV.js");
+const require_utils = require("./utils-D7Ygohep.js");
+const require_tailwindcss = require("./tailwindcss-glCm_d3H.js");
+const require_bundle_state = require("./bundle-state-DgGEhk_z.js");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
 let node_module = require("node:module");
 node_module = require_chunk.__toESM(node_module);
-let node_path = require("node:path");
-node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
-let node_fs = require("node:fs");
-node_fs = require_chunk.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let micromatch = require("micromatch");
+micromatch = require_chunk.__toESM(micromatch);
 //#region src/shared/tailwindcss-css-redirect.ts
 const moduleWithMutableResolve = node_module.default;
 const patched = /* @__PURE__ */ new WeakSet();
@@ -34,6 +36,7 @@ function installTailwindcssCssRedirect(pkgDir) {
 //#region src/shared/mpx.ts
 const localRequire = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
 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);
@@ -54,19 +57,44 @@ function resolveMpxWebpackPluginDir(compiler) {
 		const projectRequire = (0, node_module.createRequire)(node_path.default.join(candidate, "package.json"));
 		return node_path.default.dirname(projectRequire.resolve("@mpxjs/webpack-plugin/package.json"));
 	} catch {}
-	return node_path.default.dirname(localRequire.resolve("@mpxjs/webpack-plugin/package.json"));
+	const cachedPackageJson = Object.keys(localRequire.cache).find((file) => MPX_WEBPACK_PLUGIN_PACKAGE_RE.test(file));
+	if (cachedPackageJson) return node_path.default.dirname(cachedPackageJson);
+	try {
+		return node_path.default.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 node_path.default.join(mpxWebpackPluginDir, request.slice(22));
+}
 function addMpxWebpackPluginAlias(alias, pkgDir) {
+	const recordLoader = node_path.default.join(pkgDir, "lib/record-loader");
+	const styleCompiler = node_path.default.join(pkgDir, "lib/style-compiler/index");
+	const stripConditionalLoader = node_path.default.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) {
@@ -75,18 +103,48 @@ function ensureResolveLoaderAlias(compiler, mpxWebpackPluginDir) {
 	compiler.options.resolveLoader.alias = alias;
 	addMpxWebpackPluginAlias(alias, mpxWebpackPluginDir);
 }
+function resolveMpxWebpackPluginRequire(compiler) {
+	const candidates = [
+		compiler?.context,
+		compiler?.options?.context,
+		node_process.default.cwd()
+	].filter((item) => typeof item === "string" && item.length > 0);
+	for (const candidate of candidates) try {
+		const projectRequire = (0, node_module.createRequire)(node_path.default.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 (0, node_module.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) => node_path.default.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);
-	ensureResolveLoaderAlias(compiler, mpxWebpackPluginDir);
+	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: /^@mpxjs\/webpack-plugin\//,
-		alias: mpxWebpackPluginDir
-	}, {
 		name: "tailwindcss",
 		alias: tailwindcssCssEntry
 	}, {
@@ -94,11 +152,10 @@ function ensureMpxTailwindcssAliases(compiler, pkgDir) {
 		alias: tailwindcssCssEntry
 	});
 	else {
-		alias["@mpxjs/webpack-plugin"] = mpxWebpackPluginDir;
-		alias["@mpxjs/webpack-plugin$"] = mpxWebpackPluginDir;
 		alias.tailwindcss = tailwindcssCssEntry;
 		alias.tailwindcss$ = tailwindcssCssEntry;
 	}
+	if (mpxWebpackPluginDir) addMpxWebpackPluginAlias(alias, mpxWebpackPluginDir);
 	return tailwindcssCssEntry;
 }
 function patchMpxLoaderResolve(loaderContext, pkgDir, enabled) {
@@ -106,10 +163,11 @@ function patchMpxLoaderResolve(loaderContext, pkgDir, enabled) {
 	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, node_path.default.join(pkgDir, request.slice(12)));
-		if (isMpxWebpackPluginRequest(request)) return originalResolve.call(this, node_process.default.cwd(), request, callback);
+		if (mpxWebpackPluginDir && isMpxWebpackPluginRequest(request)) return callback(null, resolveMpxWebpackPluginRequest(request, mpxWebpackPluginDir));
 		return originalResolve.call(this, context, request, callback);
 	};
 	wrappedResolve.__weappTwPatched = true;
@@ -145,16 +203,13 @@ function getCacheKey(filename) {
 }
 function stripResourceQuery(resource) {
 	if (typeof resource !== "string") return resource;
-	const queryIndex = resource.indexOf("?");
-	if (queryIndex !== -1) return resource.slice(0, queryIndex);
-	const hashIndex = resource.indexOf("#");
-	if (hashIndex !== -1) return resource.slice(0, hashIndex);
-	return resource;
+	return require_bundle_state.stripRequestQuery(resource);
 }
 function isCssLikeModuleResource(resource, cssMatcher, appType) {
 	if (typeof resource !== "string") return false;
 	const normalizedResource = stripResourceQuery(resource);
 	if (normalizedResource && cssMatcher(normalizedResource)) return true;
+	if (require_bundle_state.isSourceStyleRequest(resource)) return true;
 	if (appType === "mpx") return MPX_STYLE_RESOURCE_QUERY_RE.test(resource);
 	return false;
 }
@@ -162,6 +217,13 @@ function hasLoaderEntry(entries, target) {
 	if (!target) return false;
 	return entries.some((entry) => entry.loader?.includes?.(target));
 }
+function normalizeWatchPath(file) {
+	return node_path.default.resolve(file);
+}
+function isFileInContext(file, context) {
+	const relative = node_path.default.relative(normalizeWatchPath(context), normalizeWatchPath(file));
+	return relative.length > 0 && !relative.startsWith("..") && !node_path.default.isAbsolute(relative);
+}
 function toChunkFiles(files) {
 	if (!files) return [];
 	if (Array.isArray(files)) return files;
@@ -190,17 +252,38 @@ function createAssetHashByChunkMap(chunks) {
 function createRuntimeAwareCssHash(assetHash, sourceHash, runtimeSetHash) {
 	return `${assetHash ?? sourceHash}:${runtimeSetHash}`;
 }
-function hasWatchChanges(compiler) {
-	return (compiler.modifiedFiles?.size ?? 0) > 0 || (compiler.removedFiles?.size ?? 0) > 0;
+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/BaseUnifiedPlugin/v5-assets.ts
+function createWebpackSnapshotAssets(assets) {
+	return Object.fromEntries(Object.entries(assets).map(([file, asset]) => {
+		const source = asset.source();
+		return [file, {
+			fileName: file,
+			source: typeof source === "string" ? source : source?.toString() ?? "",
+			type: "asset"
+		}];
+	}));
+}
+function stringifyWebpackSource(source) {
+	if (typeof source === "string") return source;
+	return source?.toString() ?? "";
+}
 function setupWebpackV5ProcessAssetsHook(options) {
-	const { compiler, options: compilerOptions, appType, runtimeState, getRuntimeRefreshRequirement, refreshRuntimeMetadata, consumeRuntimeRefreshRequirement, debug } = options;
+	const { compiler, options: compilerOptions, appType, runtimeState, getRuntimeRefreshRequirement, refreshRuntimeMetadata, isWebpackProcessedCssAsset, consumeRuntimeRefreshRequirement, isWatchMode, runtimeClassSetManager, 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 bundleBuildState = require_bundle_state.createBundleBuildState();
+	const bundleRuntimeClassSetManager = runtimeClassSetManager ?? require_incremental_runtime_class_set.createBundleRuntimeClassSetManager();
+	let webpackWatchRuntimeScanInitialized = false;
 	compiler.hooks.compilation.tap(require_precheck.pluginName, (compilation) => {
 		compilation.hooks.processAssets.tapPromise({
 			name: require_precheck.pluginName,
@@ -209,19 +292,36 @@ function setupWebpackV5ProcessAssetsHook(options) {
 			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 getCurrentAssetSource = (file) => {
+				const asset = compilation.getAsset(file);
+				if (!asset) return;
+				return stringifyWebpackSource(asset.source.source());
+			};
+			const updateAssetIfChanged = (file, source, { notifyUpdate = true } = {}) => {
+				const nextSource = stringifyWebpackSource(source.source());
+				const previousSource = getCurrentAssetSource(file);
+				if (previousSource === nextSource) {
+					debug("asset unchanged, skip update: %s", file);
+					return false;
+				}
+				compilation.updateAsset(file, source);
+				if (notifyUpdate) compilerOptions.onUpdate(file, previousSource ?? "", nextSource);
+				return true;
+			};
 			const entries = Object.entries(assets);
 			const compilerOutputPath = compilation.compiler?.outputPath ?? compiler.outputPath;
 			const outputDir = compilerOutputPath ? node_path.default.resolve(compilerOutputPath) : compilation.outputOptions?.path ?? node_process.default.cwd();
 			const jsAssets = /* @__PURE__ */ new Map();
 			for (const [file] of entries) if (compilerOptions.jsMatcher(file) || compilerOptions.wxsMatcher(file)) {
-				const absolute = require_run_tasks.toAbsoluteOutputPath(file, outputDir);
+				const absolute = require_bundle_state.toAbsoluteOutputPath(file, outputDir);
 				jsAssets.set(absolute, file);
 			}
 			const moduleGraphOptions = {
 				resolve(specifier, importer) {
-					return require_run_tasks.resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => jsAssets.has(candidate));
+					return require_bundle_state.resolveOutputSpecifier(specifier, importer, outputDir, (candidate) => jsAssets.has(candidate));
 				},
 				load: (id) => {
 					const assetName = jsAssets.get(id);
@@ -243,12 +343,8 @@ function setupWebpackV5ProcessAssetsHook(options) {
 					const asset = compilation.getAsset(assetName);
 					if (!asset) continue;
 					const previousSource = asset.source.source();
-					const previous = typeof previousSource === "string" ? previousSource : previousSource.toString();
-					if (previous === code) continue;
-					const source = new ConcatSource(code);
-					compilation.updateAsset(assetName, source);
-					compilerOptions.onUpdate(assetName, previous, code);
-					debug("js linked handle: %s", assetName);
+					if ((typeof previousSource === "string" ? previousSource : previousSource.toString()) === code) continue;
+					if (updateAssetIfChanged(assetName, new ConcatSource(code))) debug("js linked handle: %s", assetName);
 				}
 			};
 			const groupedEntries = require_utils.getGroupedEntries(entries, compilerOptions);
@@ -261,7 +357,7 @@ function setupWebpackV5ProcessAssetsHook(options) {
 				const created = {
 					isMainChunk,
 					postcssOptions: { options: { from: file } },
-					majorVersion
+					...majorVersion === void 0 ? {} : { majorVersion }
 				};
 				cssHandlerOptionsCache.set(cacheKey, created);
 				return created;
@@ -277,64 +373,92 @@ function setupWebpackV5ProcessAssetsHook(options) {
 				cssUserHandlerOptionsCache.set(cacheKey, created);
 				return created;
 			};
+			const finalizeCssAssetSource = (source) => {
+				return require_incremental_runtime_class_set.removeTailwindSourceDirectives(require_bundle_state.stripBundlerGeneratedCssMarkers(source), { importFallback: true });
+			};
 			const forceRuntimeRefresh = getRuntimeRefreshRequirement();
 			debug("processAssets ensure runtime set forceRefresh=%s major=%s", forceRuntimeRefresh, runtimeState.twPatcher.majorVersion ?? "unknown");
-			const runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, {
-				forceRefresh: forceRuntimeRefresh,
-				forceCollect: true,
-				clearCache: forceRuntimeRefresh,
-				allowEmpty: false
-			});
+			let runtimeSet;
+			const watchMode = isWatchMode?.() === true;
+			if (watchMode && runtimeState.twPatcher.majorVersion === 4 && !forceRuntimeRefresh) {
+				const snapshot = require_bundle_state.buildBundleSnapshot(createWebpackSnapshotAssets(assets), compilerOptions, outputDir, bundleBuildState);
+				if (!webpackWatchRuntimeScanInitialized) {
+					for (const entry of snapshot.entries) if (entry.type === "html" || entry.type === "js") snapshot.runtimeAffectingChangedByType[entry.type].add(entry.file);
+				}
+				try {
+					runtimeSet = await bundleRuntimeClassSetManager.sync(runtimeState.twPatcher, snapshot);
+				} catch (error) {
+					debug("webpack incremental runtime set sync failed, fallback to full collect: %O", error);
+					await bundleRuntimeClassSetManager.reset();
+					runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, {
+						forceRefresh: false,
+						forceCollect: true,
+						clearCache: false,
+						allowEmpty: false
+					});
+				}
+				require_bundle_state.updateBundleBuildState(bundleBuildState, snapshot, /* @__PURE__ */ new Map(), { incremental: true });
+				webpackWatchRuntimeScanInitialized = true;
+			} else {
+				if (forceRuntimeRefresh) {
+					await bundleRuntimeClassSetManager.reset();
+					webpackWatchRuntimeScanInitialized = false;
+				}
+				runtimeSet = await require_precheck.ensureRuntimeClassSet(runtimeState, {
+					forceRefresh: forceRuntimeRefresh,
+					forceCollect: !watchMode || forceRuntimeRefresh,
+					clearCache: forceRuntimeRefresh,
+					allowEmpty: false
+				});
+			}
 			await refreshRuntimeMetadata(forceRuntimeRefresh);
 			consumeRuntimeRefreshRequirement();
-			const runtimeSetHash = compilerOptions.cache.computeHash([require_cache.getRuntimeClassSetSignature(runtimeState.twPatcher), [...runtimeSet].sort().join("\n")].join("\n\n"));
+			const runtimeSetHash = compilerOptions.cache.computeHash([require_v3_engine.getRuntimeClassSetSignature(runtimeState.twPatcher), [...runtimeSet].sort().join("\n")].join("\n\n"));
 			const defaultTemplateHandlerOptions = { runtimeSet };
 			debug("get runtimeSet, class count: %d", runtimeSet.size);
 			const tasks = [];
-			if (Array.isArray(groupedEntries.html)) for (const element of groupedEntries.html) {
+			if (!isWebGeneratorTarget && Array.isArray(groupedEntries.html)) for (const element of groupedEntries.html) {
 				const [file, originalSource] = element;
 				const rawSource = originalSource.source().toString();
 				const cacheKey = file;
 				const chunkHash = assetHashByChunk.get(file);
-				tasks.push(require_generator_css.processCachedTask({
+				tasks.push(require_incremental_runtime_class_set.processCachedTask({
 					cache: compilerOptions.cache,
 					cacheKey,
 					hashKey: `${file}:asset`,
 					rawSource,
 					hash: chunkHash,
-					applyResult(source) {
-						compilation.updateAsset(file, source);
+					applyResult(source, { cacheHit }) {
+						updateAssetIfChanged(file, source, { notifyUpdate: !cacheHit });
 					},
 					onCacheHit() {
 						debug("html cache hit: %s", file);
 					},
 					transform: async () => {
-						const wxml = await compilerOptions.templateHandler(rawSource, defaultTemplateHandlerOptions);
-						const source = new ConcatSource(wxml);
-						compilerOptions.onUpdate(file, rawSource, wxml);
+						const source = new ConcatSource(await compilerOptions.templateHandler(rawSource, defaultTemplateHandlerOptions));
 						debug("html handle: %s", file);
 						return { result: source };
 					}
 				}));
 			}
 			const jsTaskFactories = [];
-			if (Array.isArray(groupedEntries.js)) for (const [file] of groupedEntries.js) {
+			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 absoluteFile = require_run_tasks.toAbsoluteOutputPath(file, outputDir);
+				const absoluteFile = require_bundle_state.toAbsoluteOutputPath(file, outputDir);
 				const initialSource = asset.source.source();
 				const initialRawSource = typeof initialSource === "string" ? initialSource : initialSource.toString();
 				const chunkHash = assetHashByChunk.get(file);
 				jsTaskFactories.push(async () => {
-					await require_generator_css.processCachedTask({
+					await require_incremental_runtime_class_set.processCachedTask({
 						cache: compilerOptions.cache,
 						cacheKey,
 						hashKey: `${file}:asset`,
 						rawSource: initialRawSource,
 						hash: chunkHash,
-						applyResult(source) {
-							compilation.updateAsset(file, source);
+						applyResult(source, { cacheHit }) {
+							updateAssetIfChanged(file, source, { notifyUpdate: !cacheHit });
 						},
 						onCacheHit() {
 							debug("js cache hit: %s", file);
@@ -348,10 +472,12 @@ function setupWebpackV5ProcessAssetsHook(options) {
 								moduleGraph: moduleGraphOptions,
 								babelParserOptions: { sourceFilename: absoluteFile }
 							};
-							if (require_precheck.shouldSkipJsTransform(currentSource, handlerOptions)) return { result: new ConcatSource(currentSource) };
+							if (require_precheck.shouldSkipJsTransform(currentSource, {
+								...handlerOptions,
+								classNameSet: runtimeSet
+							})) return { result: new ConcatSource(currentSource) };
 							const { code, linked } = await compilerOptions.jsHandler(currentSource, runtimeSet, handlerOptions);
 							const source = new ConcatSource(code);
-							compilerOptions.onUpdate(file, currentSource, code);
 							debug("js handle: %s", file);
 							applyLinkedResults(linked);
 							return { result: source };
@@ -362,16 +488,37 @@ function setupWebpackV5ProcessAssetsHook(options) {
 			if (Array.isArray(groupedEntries.css)) for (const element of groupedEntries.css) {
 				const [file, originalSource] = element;
 				const rawSource = originalSource.source().toString();
+				if (isWebpackProcessedCssAsset?.(file, rawSource)) {
+					const nextCss = finalizeCssAssetSource(rawSource);
+					tasks.push(require_incremental_runtime_class_set.processCachedTask({
+						cache: compilerOptions.cache,
+						cacheKey: file,
+						hashKey: `${file}:asset`,
+						rawSource,
+						hash: createRuntimeAwareCssHash(assetHashByChunk.get(file), compilerOptions.cache.computeHash(rawSource), runtimeSetHash),
+						applyResult(source, { cacheHit }) {
+							updateAssetIfChanged(file, source, { notifyUpdate: !cacheHit });
+						},
+						onCacheHit() {
+							debug("css webpack-loader-pipeline cache hit: %s", file);
+						},
+						transform: async () => {
+							debug("css skip webpack-loader-pipeline asset: %s", file);
+							return { result: new ConcatSource(nextCss) };
+						}
+					}));
+					continue;
+				}
 				const cacheKey = file;
 				const runtimeAwareHash = createRuntimeAwareCssHash(assetHashByChunk.get(file), compilerOptions.cache.computeHash(rawSource), runtimeSetHash);
-				tasks.push(require_generator_css.processCachedTask({
+				tasks.push(require_incremental_runtime_class_set.processCachedTask({
 					cache: compilerOptions.cache,
 					cacheKey,
 					hashKey: `${file}:asset`,
 					rawSource,
 					hash: runtimeAwareHash,
-					applyResult(source) {
-						compilation.updateAsset(file, source);
+					applyResult(source, { cacheHit }) {
+						updateAssetIfChanged(file, source, { notifyUpdate: !cacheHit });
 					},
 					onCacheHit() {
 						debug("css cache hit: %s", file);
@@ -379,7 +526,7 @@ function setupWebpackV5ProcessAssetsHook(options) {
 					transform: async () => {
 						await runtimeState.readyPromise;
 						const cssHandlerOptions = getCssHandlerOptions(file);
-						const generated = await require_generator_css.generateCssByGenerator({
+						const generated = await require_incremental_runtime_class_set.generateCssByGenerator({
 							opts: compilerOptions,
 							runtimeState,
 							runtime: runtimeSet,
@@ -390,23 +537,29 @@ function setupWebpackV5ProcessAssetsHook(options) {
 							styleHandler: compilerOptions.styleHandler,
 							debug
 						});
-						const css = generated?.css ?? (await compilerOptions.styleHandler(rawSource, cssHandlerOptions)).css;
-						const source = new ConcatSource(css);
-						compilerOptions.onUpdate(file, rawSource, css);
+						const source = new ConcatSource(finalizeCssAssetSource(generated?.css ?? (await compilerOptions.styleHandler(rawSource, cssHandlerOptions)).css));
 						if (generated) debug("css handle via tailwind v%s engine(%s): %s", runtimeState.twPatcher.majorVersion, generated.target, file);
 						else debug("css handle: %s", file);
 						return { result: source };
 					}
 				}));
 			}
-			require_run_tasks.pushConcurrentTaskFactories(tasks, jsTaskFactories);
+			require_bundle_state.pushConcurrentTaskFactories(tasks, jsTaskFactories);
 			await Promise.all(tasks);
 			debug("end");
+			require_incremental_runtime_class_set.emitHmrTiming("webpack", "processAssets", performance.now() - hmrTimingStartedAt);
 			compilerOptions.onEnd();
 		});
 	});
 }
 //#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);
+}
+//#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";
@@ -437,7 +590,7 @@ function createLoaderAnchorFinders(appType) {
 //#endregion
 //#region src/bundlers/webpack/BaseUnifiedPlugin/v5-loaders.ts
 function setupWebpackV5Loaders(options) {
-	const { compiler, options: compilerOptions, appType, weappTailwindcssPackageDir, shouldRewriteCssImports, runtimeLoaderPath, registerAutoCssSource, getClassSetInLoader, getRuntimeWatchDependencies, debug } = options;
+	const { compiler, options: compilerOptions, appType, weappTailwindcssPackageDir, shouldRewriteCssImports, runtimeLoaderPath, registerAutoCssSource, runtimeState, getClassSetInLoader, getRuntimeSetInLoader, markWebpackProcessedCssSource, getRuntimeWatchDependencies, runtimeRegistryKey = `weapp-tailwindcss-${Date.now()}-${Math.random().toString(36).slice(2)}`, debug } = options;
 	const isMpxApp = isMpx(appType);
 	if (shouldRewriteCssImports && isMpxApp) ensureMpxTailwindcssAliases(compiler, weappTailwindcssPackageDir);
 	const runtimeClassSetLoader = runtimeLoaderPath ?? node_path.default.resolve(__dirname, "./weapp-tw-runtime-classset-loader.js");
@@ -446,24 +599,31 @@ function setupWebpackV5Loaders(options) {
 	const runtimeCssImportRewriteLoaderExists = runtimeCssImportRewriteLoader ? node_fs.default.existsSync(runtimeCssImportRewriteLoader) : false;
 	const runtimeLoaderRewriteOptions = shouldRewriteCssImports ? {
 		pkgDir: weappTailwindcssPackageDir,
-		appType,
-		registerCssSource: registerAutoCssSource
+		compilerOptions,
+		runtimeState,
+		...appType === void 0 ? {} : { appType },
+		...registerAutoCssSource === void 0 ? {} : { registerCssSource: registerAutoCssSource },
+		getRuntimeSet: getRuntimeSetInLoader,
+		...markWebpackProcessedCssSource === void 0 ? {} : { markGeneratedCssSource: markWebpackProcessedCssSource }
 	} : void 0;
-	const classSetLoaderOptions = {
-		getClassSet: getClassSetInLoader,
-		getWatchDependencies: getRuntimeWatchDependencies
-	};
+	setWebpackLoaderRuntime(runtimeRegistryKey, {
+		classSet: {
+			getClassSet: getClassSetInLoader,
+			getWatchDependencies: getRuntimeWatchDependencies
+		},
+		...runtimeLoaderRewriteOptions === void 0 ? {} : { cssImportRewrite: runtimeLoaderRewriteOptions }
+	});
 	const { findRewriteAnchor, findClassSetAnchor } = createLoaderAnchorFinders(appType);
-	const cssImportRewriteLoaderOptions = runtimeLoaderRewriteOptions ? { tailwindcssImportRewrite: runtimeLoaderRewriteOptions } : void 0;
+	const cssImportRewriteLoaderOptions = runtimeLoaderRewriteOptions ? { tailwindcssImportRewriteRuntimeKey: runtimeRegistryKey } : void 0;
 	if (runtimeCssImportRewriteLoader && shouldRewriteCssImports && cssImportRewriteLoaderOptions && isMpxApp) injectMpxCssRewritePreRules(compiler, runtimeCssImportRewriteLoader, cssImportRewriteLoaderOptions);
 	const createRuntimeClassSetLoaderEntry = () => ({
 		loader: runtimeClassSetLoader,
-		options: classSetLoaderOptions,
+		options: { weappTailwindcssRuntimeKey: runtimeRegistryKey },
 		ident: null,
 		type: null
 	});
 	const createCssImportRewriteLoaderEntry = () => {
-		if (!runtimeCssImportRewriteLoader) return null;
+		if (!runtimeCssImportRewriteLoader || !cssImportRewriteLoaderOptions) return null;
 		return {
 			loader: runtimeCssImportRewriteLoader,
 			options: cssImportRewriteLoaderOptions,
@@ -480,15 +640,15 @@ function setupWebpackV5Loaders(options) {
 			let rewriteAnchorIdx = findRewriteAnchor(loaderEntries);
 			const classSetAnchorIdx = findClassSetAnchor(loaderEntries);
 			const isCssModule = isCssLikeModuleResource(module.resource, compilerOptions.cssMatcher, appType);
-			if (node_process.default.env.WEAPP_TW_LOADER_DEBUG && isCssModule) debug("loader hook css module: %s loaders=%o anchors=%o", module.resource, loaderEntries.map((x) => x.loader), {
+			if (node_process.default.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 (node_process.default.env.WEAPP_TW_LOADER_DEBUG && typeof module.resource === "string" && module.resource.includes("app.css")) debug("app.css module loaders=%o anchors=%o", loaderEntries.map((x) => x.loader), {
+			if (node_process.default.env["WEAPP_TW_LOADER_DEBUG"] && typeof module.resource === "string" && module.resource.includes("app.css")) debug("app.css module loaders=%o anchors=%o", loaderEntries.map((x) => x.loader), {
 				rewriteAnchorIdx,
 				classSetAnchorIdx
 			});
-			else if (node_process.default.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), {
+			else if (node_process.default.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
 			});
@@ -521,14 +681,66 @@ function setupWebpackV5Loaders(options) {
 }
 //#endregion
 //#region src/bundlers/webpack/BaseUnifiedPlugin/v5.ts
-const debug = require_runtime_patch.createDebug();
-const weappTailwindcssPackageDir = require_run_tasks.resolvePackageDir("weapp-tailwindcss");
+require_precheck.init_defineProperty();
+const debug = require_v3_engine.createDebug();
+const weappTailwindcssPackageDir = require_bundle_state.resolvePackageDir("weapp-tailwindcss");
+const outputIgnoredPredicatePath = Symbol("weapp-tailwindcss.outputIgnoredPredicatePath");
+function normalizeIgnoredList(ignored) {
+	if (Array.isArray(ignored)) return ignored.filter((item) => typeof item === "string" || item instanceof RegExp || typeof item === "function");
+	if (typeof ignored === "string" || ignored instanceof RegExp || typeof ignored === "function") return [ignored];
+	return [];
+}
+function createOutputIgnoredPredicate(ignoredList, ignoredPath) {
+	const predicate = (file) => {
+		const resolvedFile = node_path.default.resolve(file);
+		if (resolvedFile === ignoredPath || resolvedFile.startsWith(`${ignoredPath}${node_path.default.sep}`)) return true;
+		const normalizedFile = file.replace(/\\/g, "/");
+		return ignoredList.some((item) => {
+			if (typeof item === "string") {
+				const resolvedItem = node_path.default.resolve(item);
+				if (resolvedFile === resolvedItem || resolvedFile.startsWith(`${resolvedItem}${node_path.default.sep}`)) return true;
+				return micromatch.default.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" && node_path.default.resolve(item) === ignoredPath)) return ignored;
+	return [...ignoredList, ignoredPath];
+}
+function setupWebpackWatchOutputIgnore(compiler) {
+	const appendOutputIgnoredPath = (watchOptions) => {
+		const outputPath = compiler.outputPath || compiler.options?.output?.path;
+		const outputDir = outputPath ? node_path.default.resolve(outputPath) : void 0;
+		if (!outputDir) return watchOptions;
+		if (watchOptions && typeof watchOptions === "object") {
+			watchOptions.ignored = appendIgnoredPath(watchOptions.ignored, outputDir);
+			return watchOptions;
+		}
+		return { ignored: appendIgnoredPath(void 0, outputDir) };
+	};
+	compiler.options.watchOptions = appendOutputIgnoredPath(compiler.options.watchOptions);
+	const syncOutputIgnoredPath = () => {
+		const outputPath = compiler.outputPath || compiler.options?.output?.path;
+		if (!(outputPath ? node_path.default.resolve(outputPath) : void 0)) return;
+		const watchOptions = compiler.watching?.watchOptions;
+		if (watchOptions) appendOutputIgnoredPath(watchOptions);
+	};
+	compiler.hooks.watchRun?.tap(require_precheck.pluginName, syncOutputIgnoredPath);
+}
 /**
-* @name UnifiedWebpackPluginV5
+* @name WeappTailwindcss
 * @description webpack5 核心转义插件
 * @link https://tw.icebreaker.top/docs/intro
 */
-var UnifiedWebpackPluginV5 = class {
+var WeappTailwindcss = class {
 	constructor(options = {}) {
 		require_precheck._defineProperty(this, "options", void 0);
 		require_precheck._defineProperty(this, "appType", void 0);
@@ -543,11 +755,14 @@ var UnifiedWebpackPluginV5 = class {
 	apply(compiler) {
 		compiler.options = compiler.options || {};
 		const { disabled, onLoad, runtimeLoaderPath, twPatcher: initialTwPatcher, refreshTailwindcssPatcher } = this.options;
-		const disabledOptions = require_run_tasks.resolvePluginDisabledState(disabled);
-		const shouldRewriteCssImports = (initialTwPatcher.majorVersion ?? 0) >= 4;
+		const disabledOptions = require_bundle_state.resolvePluginDisabledState(disabled);
+		const isTailwindcssV4 = (initialTwPatcher.majorVersion ?? 0) >= 4;
+		const generatorOptions = require_generator.normalizeWeappTailwindcssGeneratorOptions(this.options.generator);
+		const shouldRewriteCssImports = isTailwindcssV4 || generatorOptions.target === "web";
 		const isMpxApp = isMpx(this.appType);
 		if (shouldRewriteCssImports) setupMpxTailwindcssRedirect(weappTailwindcssPackageDir, isMpxApp);
 		if (disabledOptions.plugin) return;
+		setupWebpackWatchOutputIgnore(compiler);
 		const runtimeState = {
 			twPatcher: initialTwPatcher,
 			readyPromise: require_precheck.createTailwindRuntimeReadyPromise(initialTwPatcher),
@@ -556,13 +771,15 @@ var UnifiedWebpackPluginV5 = class {
 		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();
 		let runtimeMetadataPrepared = false;
 		const updateRuntimeWatchDependencies = async () => {
 			runtimeWatchDependencyFiles.clear();
 			runtimeWatchDependencyContexts.clear();
-			const tailwindOptions = require_cache.resolveTailwindcssOptions(runtimeState.twPatcher.options);
+			const tailwindOptions = require_v3_engine.resolveTailwindcssOptions(runtimeState.twPatcher.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 ?? []) {
@@ -584,12 +801,24 @@ var UnifiedWebpackPluginV5 = class {
 			await updateRuntimeWatchDependencies();
 			runtimeMetadataPrepared = true;
 		};
-		const syncRuntimeRefreshRequirement = () => {
-			runtimeRefreshRequiredForCompilation = runtimeRefreshRequiredForCompilation || hasWatchChanges(compiler);
+		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;
-			runtimeMetadataPrepared = false;
 			syncRuntimeRefreshRequirement();
 		};
 		const registerAutoCssSource = async (source) => {
@@ -604,21 +833,25 @@ var UnifiedWebpackPluginV5 = class {
 			});
 			debug("detected tailwindcss v4 css source from webpack css module: %s", source.file);
 		};
-		compiler.hooks.invalid?.tap?.(require_precheck.pluginName, () => {
-			runtimeRefreshRequiredForCompilation = true;
+		const markWebpackProcessedCssSource = (file) => {
+			webpackProcessedCssSourceFiles.add(node_path.default.resolve(file));
+		};
+		compiler.hooks.invalid?.tap?.(require_precheck.pluginName, (fileName) => {
+			if (!fileName) return;
+			runtimeRefreshRequiredForCompilation = runtimeRefreshRequiredForCompilation || hasRuntimeDependencyChanges([node_path.default.resolve(fileName)]);
 		});
-		compiler.hooks.watchRun?.tap?.(require_precheck.pluginName, syncRuntimeRefreshRequirement);
+		compiler.hooks.watchRun?.tap?.(require_precheck.pluginName, () => syncRuntimeRefreshRequirement(true));
 		if (compiler.hooks.thisCompilation?.tap) compiler.hooks.thisCompilation.tap(require_precheck.pluginName, resetRuntimePreparation);
 		else if (compiler.hooks.compilation?.tap) compiler.hooks.compilation.tap(require_precheck.pluginName, resetRuntimePreparation);
 		async function getClassSetInLoader() {
 			if (runtimeSetPrepared) return;
-			const signature = require_cache.getRuntimeClassSetSignature(runtimeState.twPatcher);
+			const signature = require_v3_engine.getRuntimeClassSetSignature(runtimeState.twPatcher);
 			const forceRefresh = runtimeRefreshRequiredForCompilation || signature !== runtimeSetSignature;
 			debug("runtime loader ensure class set forceRefresh=%s watchDirty=%s signatureChanged=%s", forceRefresh, runtimeRefreshRequiredForCompilation, signature !== runtimeSetSignature);
 			runtimeSetPrepared = true;
 			await require_precheck.ensureRuntimeClassSet(runtimeState, {
 				forceRefresh,
-				forceCollect: true,
+				forceCollect: forceRefresh || !watchRunObserved,
 				clearCache: forceRefresh,
 				allowEmpty: true
 			});
@@ -626,6 +859,10 @@ var UnifiedWebpackPluginV5 = class {
 			runtimeSetSignature = signature;
 			runtimeRefreshRequiredForCompilation = false;
 		}
+		async function getRuntimeSetInLoader() {
+			await getClassSetInLoader();
+			return require_precheck.ensureRuntimeClassSet(runtimeState, { allowEmpty: true });
+		}
 		onLoad();
 		setupWebpackV5Loaders({
 			compiler,
@@ -635,7 +872,10 @@ var UnifiedWebpackPluginV5 = class {
 			shouldRewriteCssImports,
 			runtimeLoaderPath,
 			registerAutoCssSource,
+			runtimeState,
 			getClassSetInLoader,
+			getRuntimeSetInLoader,
+			markWebpackProcessedCssSource,
 			getRuntimeWatchDependencies() {
 				return {
 					files: runtimeWatchDependencyFiles,
@@ -651,18 +891,23 @@ var UnifiedWebpackPluginV5 = class {
 			runtimeState,
 			getRuntimeRefreshRequirement: () => runtimeRefreshRequiredForCompilation,
 			refreshRuntimeMetadata: ensureRuntimeMetadata,
+			isWebpackProcessedCssAsset(file, rawSource) {
+				return webpackProcessedCssSourceFiles.has(node_path.default.resolve(file)) || rawSource.includes("weapp-tailwindcss webpack-generated-css");
+			},
 			consumeRuntimeRefreshRequirement() {
 				runtimeRefreshRequiredForCompilation = false;
 			},
+			isWatchMode: () => watchRunObserved || compiler.options?.watch === true,
+			runtimeClassSetManager: this.options.__internalWebpackRuntimeClassSetManager,
 			debug
 		});
 	}
 };
 //#endregion
-Object.defineProperty(exports, "UnifiedWebpackPluginV5", {
+Object.defineProperty(exports, "WeappTailwindcss", {
 	enumerable: true,
 	get: function() {
-		return UnifiedWebpackPluginV5;
+		return WeappTailwindcss;
 	}
 });
 Object.defineProperty(exports, "weappTailwindcssPackageDir", {