weapp-tailwindcss 5.0.0-next.11 → 5.0.0-next.14

package/dist/{precheck-D5eEdqeH.js → precheck-CZHcFX8k.js}

@@ -1,17 +1,16 @@
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_cache = require("./cache-B_9E7FxF.js");
-const require_runtime_patch = require("./runtime-patch-CqB-A4zA.js");
+const require_v3_engine = require("./v3-engine-DwV1E6rX.js");
+const require_defaults = require("./defaults-IHhYxNeU.js");
 require("./utils-4ODFyoqD.js");
-const require_defaults = require("./defaults.js");
-const require_tailwindcss = require("./tailwindcss-B78nj6n7.js");
+const require_tailwindcss = require("./tailwindcss-CN0K7G-l.js");
 let node_path = require("node:path");
 node_path = require_chunk.__toESM(node_path);
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
 let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
+let node_fs_promises = require("node:fs/promises");
 let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
 let node_buffer = require("node:buffer");
-let node_fs_promises = require("node:fs/promises");
 let lru_cache = require("lru-cache");
 let _weapp_tailwindcss_shared_node = require("@weapp-tailwindcss/shared/node");
 let _weapp_core_escape = require("@weapp-core/escape");
@@ -110,12 +109,12 @@ function initializeCache(cacheConfig) {
 }
 //#endregion
 //#region src/tailwindcss/runtime.ts
-const debug$1 = require_runtime_patch.createDebug("[tailwindcss:runtime] ");
+const debug$1 = require_v3_engine.createDebug("[tailwindcss:runtime] ");
 const refreshTailwindcssPatcherSymbol = Symbol.for("weapp-tailwindcss.refreshTailwindcssPatcher");
 function createTailwindRuntimeReadyPromise(twPatcher) {
 	return Promise.resolve().then(async () => {
-		await require_runtime_patch.ensureTailwindcssRuntimePatch(twPatcher);
-		require_cache.invalidateRuntimeClassSet(twPatcher);
+		await require_v3_engine.ensureTailwindcssRuntimePatch(twPatcher);
+		require_v3_engine.invalidateRuntimeClassSet(twPatcher);
 	});
 }
 const runtimeClassSetStateCache = /* @__PURE__ */ new WeakMap();
@@ -155,7 +154,7 @@ async function ensureRuntimeClassSet(state, options = {}) {
 	});
 	await state.readyPromise;
 	const entry = getRuntimeClassSetStateEntry(state);
-	const signature = require_cache.getRuntimeClassSetSignature(state.twPatcher);
+	const signature = await require_v3_engine.getRuntimeClassSetSignatureWithSources(state.twPatcher);
 	const signatureChanged = entry.signature !== signature;
 	const shouldForceCollect = forceCollect || forceRefresh || signatureChanged;
 	if (!shouldForceCollect) {
@@ -184,7 +183,7 @@ async function ensureRuntimeClassSet(state, options = {}) {
 	try {
 		const runtimeSet = await task;
 		entry.value = runtimeSet;
-		entry.signature = require_cache.getRuntimeClassSetSignature(state.twPatcher);
+		entry.signature = await require_v3_engine.getRuntimeClassSetSignatureWithSources(state.twPatcher);
 		return runtimeSet;
 	} finally {
 		if (entry.promise === task) entry.promise = void 0;
@@ -209,6 +208,19 @@ function tryGetRuntimeClassSetSync(twPatcher) {
 		return;
 	}
 }
+async function collectTailwindV4GeneratorClassSet(twPatcher) {
+	try {
+		const generated = await require_v3_engine.createTailwindV4Engine(await require_v3_engine.resolveTailwindV4SourceFromPatcher(twPatcher)).generate({
+			scanSources: true,
+			target: "tailwind"
+		});
+		debug$1("runtime class set resolved via tailwindcss v4 generator source scan, size=%d", generated.classSet.size);
+		return generated.classSet;
+	} catch (error) {
+		debug$1("tailwindcss v4 generator source scan failed, continuing fallback chain: %O", error);
+		return;
+	}
+}
 async function collectRuntimeClassSet(twPatcher, options = {}) {
 	let activePatcher = twPatcher;
 	if (options.force && !options.skipRefresh) {
@@ -220,14 +232,14 @@ async function collectRuntimeClassSet(twPatcher, options = {}) {
 			debug$1("refreshTailwindcssPatcher failed, continuing with existing patcher: %O", error);
 		}
 	}
-	const entry = require_cache.getRuntimeClassSetCacheEntry(activePatcher);
-	const signature = require_cache.getRuntimeClassSetSignature(activePatcher);
+	const entry = require_v3_engine.getRuntimeClassSetCacheEntry(activePatcher);
+	const signature = await require_v3_engine.getRuntimeClassSetSignatureWithSources(activePatcher);
 	if (!options.force) {
 		if (entry.value && entry.signature === signature) return entry.value;
 		if (entry.promise) return entry.promise;
 	} else entry.value = void 0;
 	const task = (async () => {
-		await require_runtime_patch.ensureTailwindcssRuntimePatch(activePatcher);
+		await require_v3_engine.ensureTailwindcssRuntimePatch(activePatcher);
 		const preExtractSyncSet = options.force ? tryGetRuntimeClassSetSync(activePatcher) : void 0;
 		if (preExtractSyncSet) debug$1("runtime class set snapshot via getClassSetSync() before extract(), size=%d", preExtractSyncSet.size);
 		const preferExtract = options.force === true;
@@ -238,12 +250,20 @@ async function collectRuntimeClassSet(twPatcher, options = {}) {
 					debug$1("runtime class set resolved via extract(), size=%d", result.classSet.size);
 					return result.classSet;
 				}
-				if (preferExtract) debug$1("runtime class set from extract() is empty on force collect, fallback to sync/async class set");
+				if (preferExtract && activePatcher.majorVersion !== 4) {
+					debug$1("runtime class set resolved via empty extract() on force collect, size=0");
+					return result.classSet;
+				}
+				if (preferExtract) debug$1("runtime class set from extract() is empty on force collect, fallback to generator/sync/async class set");
 				else debug$1("runtime class set from extract() is empty, fallback to sync/async class set");
 			}
 		} catch (error) {
 			debug$1("extract() failed, fallback to getClassSet(): %O", error);
 		}
+		if (activePatcher.majorVersion === 4) {
+			const generatorClassSet = await collectTailwindV4GeneratorClassSet(activePatcher);
+			if (generatorClassSet && generatorClassSet.size > 0) return generatorClassSet;
+		}
 		if (preExtractSyncSet) {
 			debug$1("runtime class set fallback to pre-extract sync snapshot, size=%d", preExtractSyncSet.size);
 			return preExtractSyncSet;
@@ -610,20 +630,40 @@ function createNameMatcher(list, { exact = false } = {}) {
 }
 //#endregion
 //#region src/js/babel/parse.ts
-const parseCache = new lru_cache.LRUCache({ max: 1024 });
+const parseCache = new lru_cache.LRUCache({ max: require_defaults.HARD_PARSE_CACHE_MAX_ENTRIES });
 function genCacheKey(source, options) {
-	if (typeof options === "string") return source + options;
-	return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
+	if (typeof options === "string") return `${(0, _weapp_tailwindcss_shared_node.md5)(source)}:${options}`;
+	return `${(0, _weapp_tailwindcss_shared_node.md5)(source)}:${JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val)}`;
+}
+function normalizeCacheMaxEntries(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 128;
+	return Math.min(Math.max(Math.floor(value), 0), require_defaults.HARD_PARSE_CACHE_MAX_ENTRIES);
+}
+function normalizeCacheMaxSourceLength(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return require_defaults.DEFAULT_PARSE_CACHE_MAX_SOURCE_LENGTH;
+	return Math.max(Math.floor(value), 0);
+}
+function trimParseCache(maxEntries) {
+	while (parseCache.size > maxEntries) parseCache.pop();
 }
 function babelParse(code, opts = {}) {
-	const { cache, cacheKey, ...rest } = opts;
-	const cacheKeyString = genCacheKey(code, cacheKey ?? rest);
+	const { cache, cacheKey, cacheMaxEntries, cacheMaxSourceLength, ...rest } = opts;
+	const maxEntries = normalizeCacheMaxEntries(cacheMaxEntries);
+	const maxSourceLength = normalizeCacheMaxSourceLength(cacheMaxSourceLength);
+	const shouldCache = cache === true && maxEntries > 0 && code.length <= maxSourceLength;
+	const cacheKeyString = shouldCache ? genCacheKey(code, cacheKey ?? rest) : void 0;
 	let result;
-	if (cache) result = parseCache.get(cacheKeyString);
+	if (shouldCache) {
+		trimParseCache(maxEntries);
+		result = parseCache.get(cacheKeyString);
+	}
 	if (!result) {
-		const { cache: _cache, cacheKey: _cacheKey, ...parseOptions } = opts;
+		const { cache: _cache, cacheKey: _cacheKey, cacheMaxEntries: _cacheMaxEntries, cacheMaxSourceLength: _cacheMaxSourceLength, ...parseOptions } = opts;
 		result = (0, _babel_parser.parse)(code, parseOptions);
-		if (cache) parseCache.set(cacheKeyString, result);
+		if (shouldCache) {
+			parseCache.set(cacheKeyString, result);
+			trimParseCache(maxEntries);
+		}
 	}
 	return result;
 }
@@ -637,7 +677,7 @@ function replaceWxml(original, options = {
 	const { keepEOL, escapeMap, ignoreHead } = options;
 	let res = original;
 	if (!keepEOL) res = res.replaceAll(NEWLINE_RE, "");
-	res = (0, _weapp_core_escape.escape)(res, require_cache.omitUndefined({
+	res = (0, _weapp_core_escape.escape)(res, require_v3_engine.omitUndefined({
 		map: escapeMap,
 		ignoreHead
 	}));
@@ -837,7 +877,7 @@ function isClassContextLiteralPath(path) {
 }
 //#endregion
 //#region src/js/handlers.ts
-const debug = require_runtime_patch.createDebug("[js:handlers] ");
+const debug = require_v3_engine.createDebug("[js:handlers] ");
 const replacementCacheByEscapeMap = /* @__PURE__ */ new WeakMap();
 const defaultReplacementCache = /* @__PURE__ */ new Map();
 const WEAPP_TW_IGNORE_MARKER = "weapp-tw";
@@ -2587,7 +2627,7 @@ function createInternalCompilerContext(opts) {
 	const refreshTailwindcssPatcher = async (options) => {
 		const previousPatcher = ctx.twPatcher;
 		if (options?.clearCache !== false) await clearTailwindcssPatcherCache(previousPatcher);
-		require_cache.invalidateRuntimeClassSet(previousPatcher);
+		require_v3_engine.invalidateRuntimeClassSet(previousPatcher);
 		const nextPatcher = require_tailwindcss.createTailwindcssPatcherFromContext(ctx);
 		Object.assign(previousPatcher, nextPatcher);
 		ctx.twPatcher = previousPatcher;

package/dist/{precheck-DtBGFS-n.mjs → precheck-DCresEiu.mjs}

@@ -1,14 +1,13 @@
-import { l as omitUndefined, n as getRuntimeClassSetSignature, r as invalidateRuntimeClassSet, t as getRuntimeClassSetCacheEntry } from "./cache-DEDxBMIw.mjs";
-import { n as createDebug, t as ensureTailwindcssRuntimePatch } from "./runtime-patch-DGKsVkiG.mjs";
+import { B as omitUndefined, C as createTailwindV4Engine, F as createDebug, c as getRuntimeClassSetCacheEntry, d as invalidateRuntimeClassSet, s as ensureTailwindcssRuntimePatch, u as getRuntimeClassSetSignatureWithSources, x as resolveTailwindV4SourceFromPatcher } from "./v3-engine-D61eilBl.mjs";
+import { a as resolveDefaultCssPreflight, i as getDefaultOptions, o as DEFAULT_PARSE_CACHE_MAX_SOURCE_LENGTH, s as HARD_PARSE_CACHE_MAX_ENTRIES } from "./defaults-B1igPF_e.mjs";
 import { i as isMap, n as defuOverrideArray } from "./utils-CGBVVNm6.mjs";
-import { getDefaultOptions, resolveDefaultCssPreflight } from "./defaults.mjs";
-import { a as applyV4CssCalcDefaults, i as resolveUniAppXOptions, o as warnMissingCssEntries, r as isUniAppXEnabled, t as createTailwindcssPatcherFromContext } from "./tailwindcss-DGM8lHUj.mjs";
+import { a as applyV4CssCalcDefaults, i as resolveUniAppXOptions, o as warnMissingCssEntries, r as isUniAppXEnabled, t as createTailwindcssPatcherFromContext } from "./tailwindcss-7k0LFa12.mjs";
 import path from "node:path";
 import process from "node:process";
 import { logger, pc } from "@weapp-tailwindcss/logger";
+import { rm } from "node:fs/promises";
 import { createStyleHandler } from "@weapp-tailwindcss/postcss";
 import { Buffer } from "node:buffer";
-import { rm } from "node:fs/promises";
 import { LRUCache } from "lru-cache";
 import { md5 as md5Hash } from "@weapp-tailwindcss/shared/node";
 import { MappingChars2String, escape } from "@weapp-core/escape";
@@ -148,7 +147,7 @@ async function ensureRuntimeClassSet(state, options = {}) {
 	});
 	await state.readyPromise;
 	const entry = getRuntimeClassSetStateEntry(state);
-	const signature = getRuntimeClassSetSignature(state.twPatcher);
+	const signature = await getRuntimeClassSetSignatureWithSources(state.twPatcher);
 	const signatureChanged = entry.signature !== signature;
 	const shouldForceCollect = forceCollect || forceRefresh || signatureChanged;
 	if (!shouldForceCollect) {
@@ -177,7 +176,7 @@ async function ensureRuntimeClassSet(state, options = {}) {
 	try {
 		const runtimeSet = await task;
 		entry.value = runtimeSet;
-		entry.signature = getRuntimeClassSetSignature(state.twPatcher);
+		entry.signature = await getRuntimeClassSetSignatureWithSources(state.twPatcher);
 		return runtimeSet;
 	} finally {
 		if (entry.promise === task) entry.promise = void 0;
@@ -202,6 +201,19 @@ function tryGetRuntimeClassSetSync(twPatcher) {
 		return;
 	}
 }
+async function collectTailwindV4GeneratorClassSet(twPatcher) {
+	try {
+		const generated = await createTailwindV4Engine(await resolveTailwindV4SourceFromPatcher(twPatcher)).generate({
+			scanSources: true,
+			target: "tailwind"
+		});
+		debug$1("runtime class set resolved via tailwindcss v4 generator source scan, size=%d", generated.classSet.size);
+		return generated.classSet;
+	} catch (error) {
+		debug$1("tailwindcss v4 generator source scan failed, continuing fallback chain: %O", error);
+		return;
+	}
+}
 async function collectRuntimeClassSet(twPatcher, options = {}) {
 	let activePatcher = twPatcher;
 	if (options.force && !options.skipRefresh) {
@@ -214,7 +226,7 @@ async function collectRuntimeClassSet(twPatcher, options = {}) {
 		}
 	}
 	const entry = getRuntimeClassSetCacheEntry(activePatcher);
-	const signature = getRuntimeClassSetSignature(activePatcher);
+	const signature = await getRuntimeClassSetSignatureWithSources(activePatcher);
 	if (!options.force) {
 		if (entry.value && entry.signature === signature) return entry.value;
 		if (entry.promise) return entry.promise;
@@ -231,12 +243,20 @@ async function collectRuntimeClassSet(twPatcher, options = {}) {
 					debug$1("runtime class set resolved via extract(), size=%d", result.classSet.size);
 					return result.classSet;
 				}
-				if (preferExtract) debug$1("runtime class set from extract() is empty on force collect, fallback to sync/async class set");
+				if (preferExtract && activePatcher.majorVersion !== 4) {
+					debug$1("runtime class set resolved via empty extract() on force collect, size=0");
+					return result.classSet;
+				}
+				if (preferExtract) debug$1("runtime class set from extract() is empty on force collect, fallback to generator/sync/async class set");
 				else debug$1("runtime class set from extract() is empty, fallback to sync/async class set");
 			}
 		} catch (error) {
 			debug$1("extract() failed, fallback to getClassSet(): %O", error);
 		}
+		if (activePatcher.majorVersion === 4) {
+			const generatorClassSet = await collectTailwindV4GeneratorClassSet(activePatcher);
+			if (generatorClassSet && generatorClassSet.size > 0) return generatorClassSet;
+		}
 		if (preExtractSyncSet) {
 			debug$1("runtime class set fallback to pre-extract sync snapshot, size=%d", preExtractSyncSet.size);
 			return preExtractSyncSet;
@@ -603,20 +623,40 @@ function createNameMatcher(list, { exact = false } = {}) {
 }
 //#endregion
 //#region src/js/babel/parse.ts
-const parseCache = new LRUCache({ max: 1024 });
+const parseCache = new LRUCache({ max: HARD_PARSE_CACHE_MAX_ENTRIES });
 function genCacheKey(source, options) {
-	if (typeof options === "string") return source + options;
-	return source + JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val);
+	if (typeof options === "string") return `${md5Hash(source)}:${options}`;
+	return `${md5Hash(source)}:${JSON.stringify(options, (_, val) => typeof val === "function" ? val.toString() : val)}`;
+}
+function normalizeCacheMaxEntries(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return 128;
+	return Math.min(Math.max(Math.floor(value), 0), HARD_PARSE_CACHE_MAX_ENTRIES);
+}
+function normalizeCacheMaxSourceLength(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_PARSE_CACHE_MAX_SOURCE_LENGTH;
+	return Math.max(Math.floor(value), 0);
+}
+function trimParseCache(maxEntries) {
+	while (parseCache.size > maxEntries) parseCache.pop();
 }
 function babelParse(code, opts = {}) {
-	const { cache, cacheKey, ...rest } = opts;
-	const cacheKeyString = genCacheKey(code, cacheKey ?? rest);
+	const { cache, cacheKey, cacheMaxEntries, cacheMaxSourceLength, ...rest } = opts;
+	const maxEntries = normalizeCacheMaxEntries(cacheMaxEntries);
+	const maxSourceLength = normalizeCacheMaxSourceLength(cacheMaxSourceLength);
+	const shouldCache = cache === true && maxEntries > 0 && code.length <= maxSourceLength;
+	const cacheKeyString = shouldCache ? genCacheKey(code, cacheKey ?? rest) : void 0;
 	let result;
-	if (cache) result = parseCache.get(cacheKeyString);
+	if (shouldCache) {
+		trimParseCache(maxEntries);
+		result = parseCache.get(cacheKeyString);
+	}
 	if (!result) {
-		const { cache: _cache, cacheKey: _cacheKey, ...parseOptions } = opts;
+		const { cache: _cache, cacheKey: _cacheKey, cacheMaxEntries: _cacheMaxEntries, cacheMaxSourceLength: _cacheMaxSourceLength, ...parseOptions } = opts;
 		result = parse(code, parseOptions);
-		if (cache) parseCache.set(cacheKeyString, result);
+		if (shouldCache) {
+			parseCache.set(cacheKeyString, result);
+			trimParseCache(maxEntries);
+		}
 	}
 	return result;
 }

package/dist/presets.js

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-8l464Juk.js");
-const require_cache = require("./cache-B_9E7FxF.js");
+const require_v3_engine = require("./v3-engine-DwV1E6rX.js");
 const require_utils = require("./utils-4ODFyoqD.js");
-const require_tailwindcss = require("./tailwindcss-B78nj6n7.js");
+const require_tailwindcss = require("./tailwindcss-CN0K7G-l.js");
 require("./logger-EVNB9z7i.js");
 let node_process = require("node:process");
 node_process = require_chunk.__toESM(node_process);
@@ -22,7 +22,7 @@ function createBasePreset(options = {}) {
 	const tailwindConfig = {
 		v2: { cwd: baseDir },
 		v3: { cwd: baseDir },
-		v4: require_cache.omitUndefined({
+		v4: require_v3_engine.omitUndefined({
 			base: baseDir,
 			cssEntries: normalizedCssEntries
 		})
@@ -109,7 +109,7 @@ function uniAppX(options) {
 				cwd: options.base,
 				resolve: resolvedResolve,
 				v3: { cwd: options.base },
-				v4: require_cache.omitUndefined({
+				v4: require_v3_engine.omitUndefined({
 					base: options.base,
 					cssEntries
 				})

package/dist/presets.mjs

@@ -1,6 +1,6 @@
-import { l as omitUndefined } from "./cache-DEDxBMIw.mjs";
+import { B as omitUndefined } from "./v3-engine-D61eilBl.mjs";
 import { n as defuOverrideArray, o as resolveUniUtsPlatform } from "./utils-CGBVVNm6.mjs";
-import { i as resolveUniAppXOptions, n as resolveTailwindcssBasedir } from "./tailwindcss-DGM8lHUj.mjs";
+import { i as resolveUniAppXOptions, n as resolveTailwindcssBasedir } from "./tailwindcss-7k0LFa12.mjs";
 import { t as logger } from "./logger-CZUxvJJD.mjs";
 import process from "node:process";
 import { getPackageInfoSync } from "local-pkg";

package/dist/source-candidates-BvbvkIPP.js

@@ -0,0 +1,274 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+const require_v3_engine = require("./v3-engine-DwV1E6rX.js");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let tailwindcss_patch = require("tailwindcss-patch");
+let node_fs_promises = require("node:fs/promises");
+let fast_glob = require("fast-glob");
+fast_glob = require_chunk.__toESM(fast_glob);
+let micromatch = require("micromatch");
+micromatch = require_chunk.__toESM(micromatch);
+//#region src/bundlers/vite/source-candidates.ts
+const CLEAN_URL_RE = /[?#].*$/;
+const SOURCE_CANDIDATE_EXTENSIONS = [
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts",
+	"vue",
+	"uvue",
+	"nvue",
+	"svelte",
+	"mpx",
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"css",
+	"wxss",
+	"acss",
+	"jxss",
+	"ttss",
+	"qss",
+	"tyss",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+];
+const SOURCE_CANDIDATE_EXTENSION_RE = /\.(?:[cm]?[jt]sx?|vue|uvue|nvue|svelte|mpx|html|wxml|axml|jxml|ksml|ttml|qml|tyml|xhsml|swan|css|wxss|acss|jxss|ttss|qss|tyss|scss|sass|less|stylus?)$/;
+const SOURCE_CANDIDATE_GLOB = `**/*.{${SOURCE_CANDIDATE_EXTENSIONS.join(",")}}`;
+const DEFAULT_SCAN_IGNORE = ["**/node_modules/**", "**/.git/**"];
+const sourceCandidateContentCache = /* @__PURE__ */ new Map();
+function cleanUrl(id) {
+	return node_path.default.resolve(id.replace(CLEAN_URL_RE, ""));
+}
+function toPosixPath(value) {
+	return value.split(node_path.default.sep).join("/");
+}
+function resolveOutDirIgnorePattern(root, outDir) {
+	if (!outDir) return;
+	const relative = node_path.default.relative(root, node_path.default.resolve(root, outDir));
+	if (!relative || relative.startsWith("..") || node_path.default.isAbsolute(relative)) return;
+	return `${toPosixPath(relative)}/**`;
+}
+function resolveSourceCandidateExtension(id) {
+	const normalized = cleanUrl(id);
+	return /\.([^.\\/]+)$/.exec(normalized)?.[1] ?? "html";
+}
+function createSourceCandidateContentCacheKey(extension, source) {
+	return `${extension}\0${source}`;
+}
+function isSourceCandidateRequest(id) {
+	return SOURCE_CANDIDATE_EXTENSION_RE.test(cleanUrl(id));
+}
+function removeCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) {
+		const count = candidateCount.get(candidate);
+		if (count == null) continue;
+		if (count <= 1) {
+			candidateCount.delete(candidate);
+			continue;
+		}
+		candidateCount.set(candidate, count - 1);
+	}
+}
+function addCandidateSet(candidateCount, candidates) {
+	for (const candidate of candidates) candidateCount.set(candidate, (candidateCount.get(candidate) ?? 0) + 1);
+}
+function isFileMatchedByEntries(file, entries) {
+	if (!entries?.length) return true;
+	const positiveEntries = entries.filter((entry) => !entry.negated);
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	if (positiveEntries.length === 0) return false;
+	const resolvedFile = node_path.default.resolve(file);
+	if (!positiveEntries.some((entry) => {
+		const relative = toPosixPath(node_path.default.relative(node_path.default.resolve(entry.base), resolvedFile));
+		const pattern = node_path.default.isAbsolute(entry.pattern) ? toPosixPath(node_path.default.relative(node_path.default.resolve(entry.base), entry.pattern)) : entry.pattern;
+		return relative && !relative.startsWith("../") && !node_path.default.isAbsolute(relative) && micromatch.default.isMatch(relative, pattern);
+	})) return false;
+	return !negativeEntries.some((entry) => {
+		const relative = toPosixPath(node_path.default.relative(node_path.default.resolve(entry.base), resolvedFile));
+		const pattern = node_path.default.isAbsolute(entry.pattern) ? toPosixPath(node_path.default.relative(node_path.default.resolve(entry.base), entry.pattern)) : entry.pattern;
+		return relative && !relative.startsWith("../") && !node_path.default.isAbsolute(relative) && micromatch.default.isMatch(relative, pattern);
+	});
+}
+function createSourceCandidateCollector() {
+	const candidatesById = /* @__PURE__ */ new Map();
+	const scanCandidatesById = /* @__PURE__ */ new Map();
+	const transformCandidatesById = /* @__PURE__ */ new Map();
+	const candidateCount = /* @__PURE__ */ new Map();
+	let inlineIncludedCandidates = /* @__PURE__ */ new Set();
+	let inlineExcludedCandidates = /* @__PURE__ */ new Set();
+	async function sync(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		if (cachedCandidates) {
+			replaceScanLayer(normalizedId, new Set(cachedCandidates));
+			return;
+		}
+		const nextCandidates = new Set(await (0, tailwindcss_patch.extractSourceCandidates)(source, extension));
+		sourceCandidateContentCache.set(contentCacheKey, [...nextCandidates]);
+		replaceScanLayer(normalizedId, nextCandidates);
+	}
+	async function merge(id, source) {
+		const normalizedId = cleanUrl(id);
+		const extension = resolveSourceCandidateExtension(normalizedId);
+		const contentCacheKey = createSourceCandidateContentCacheKey(extension, source);
+		const cachedCandidates = sourceCandidateContentCache.get(contentCacheKey);
+		const extractedCandidates = cachedCandidates ? new Set(cachedCandidates) : new Set(await (0, tailwindcss_patch.extractSourceCandidates)(source, extension));
+		if (!cachedCandidates) sourceCandidateContentCache.set(contentCacheKey, [...extractedCandidates]);
+		replaceTransformLayer(normalizedId, extractedCandidates);
+	}
+	async function syncFile(id) {
+		const normalizedId = cleanUrl(id);
+		await sync(normalizedId, await (0, node_fs_promises.readFile)(normalizedId, "utf8"));
+	}
+	async function scanRoot({ entries, root, outDir }) {
+		const resolvedRoot = node_path.default.resolve(root);
+		const outDirIgnore = resolveOutDirIgnorePattern(resolvedRoot, outDir);
+		const ignore = outDirIgnore ? [...DEFAULT_SCAN_IGNORE, outDirIgnore] : DEFAULT_SCAN_IGNORE;
+		const files = entries ? await require_v3_engine.expandTailwindSourceEntries(entries, { ignore }) : await (0, fast_glob.default)(SOURCE_CANDIDATE_GLOB, {
+			absolute: true,
+			cwd: resolvedRoot,
+			ignore,
+			onlyFiles: true,
+			unique: true
+		});
+		await Promise.all(files.map((file) => syncFile(file)));
+	}
+	function replaceFinal(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (previousCandidates) {
+			removeCandidateSet(candidateCount, previousCandidates);
+			candidatesById.delete(normalizedId);
+		}
+		if (nextCandidates.size === 0) return;
+		candidatesById.set(normalizedId, nextCandidates);
+		addCandidateSet(candidateCount, nextCandidates);
+	}
+	function replaceScanLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) scanCandidatesById.delete(normalizedId);
+		else scanCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function replaceTransformLayer(id, nextCandidates) {
+		const normalizedId = cleanUrl(id);
+		if (nextCandidates.size === 0) transformCandidatesById.delete(normalizedId);
+		else transformCandidatesById.set(normalizedId, nextCandidates);
+		recompute(normalizedId);
+	}
+	function recompute(id) {
+		const normalizedId = cleanUrl(id);
+		replaceFinal(normalizedId, new Set([...scanCandidatesById.get(normalizedId) ?? [], ...transformCandidatesById.get(normalizedId) ?? []]));
+	}
+	function syncInline(inlineCandidates) {
+		inlineIncludedCandidates = new Set(inlineCandidates?.included ?? []);
+		inlineExcludedCandidates = new Set(inlineCandidates?.excluded ?? []);
+	}
+	function remove(id) {
+		const normalizedId = cleanUrl(id);
+		scanCandidatesById.delete(normalizedId);
+		transformCandidatesById.delete(normalizedId);
+		const previousCandidates = candidatesById.get(normalizedId);
+		if (!previousCandidates) return;
+		removeCandidateSet(candidateCount, previousCandidates);
+		candidatesById.delete(normalizedId);
+	}
+	function values() {
+		const values = new Set([...candidateCount.keys(), ...inlineIncludedCandidates]);
+		for (const candidate of inlineExcludedCandidates) values.delete(candidate);
+		return values;
+	}
+	function valuesForEntries(entries) {
+		if (entries === void 0) return values();
+		const filtered = /* @__PURE__ */ new Set();
+		for (const [id, candidates] of candidatesById) {
+			if (!isFileMatchedByEntries(id, entries)) continue;
+			for (const candidate of candidates) filtered.add(candidate);
+		}
+		for (const candidate of inlineIncludedCandidates) filtered.add(candidate);
+		for (const candidate of inlineExcludedCandidates) filtered.delete(candidate);
+		return filtered;
+	}
+	function clear() {
+		candidatesById.clear();
+		scanCandidatesById.clear();
+		transformCandidatesById.clear();
+		candidateCount.clear();
+		inlineIncludedCandidates.clear();
+		inlineExcludedCandidates.clear();
+	}
+	function snapshot() {
+		return {
+			candidatesById: [...candidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			scanCandidatesById: [...scanCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			transformCandidatesById: [...transformCandidatesById.entries()].map(([id, candidates]) => [id, [...candidates]]),
+			inlineExcludedCandidates: [...inlineExcludedCandidates],
+			inlineIncludedCandidates: [...inlineIncludedCandidates]
+		};
+	}
+	function restore(snapshot) {
+		clear();
+		inlineExcludedCandidates = new Set(snapshot.inlineExcludedCandidates);
+		inlineIncludedCandidates = new Set(snapshot.inlineIncludedCandidates);
+		const scanEntries = snapshot.scanCandidatesById ?? snapshot.candidatesById;
+		for (const [id, candidates] of scanEntries) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			scanCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.transformCandidatesById ?? []) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			transformCandidatesById.set(id, candidateSet);
+		}
+		for (const [id, candidates] of snapshot.candidatesById) {
+			const candidateSet = new Set(candidates);
+			if (candidateSet.size === 0) continue;
+			candidatesById.set(id, candidateSet);
+			addCandidateSet(candidateCount, candidateSet);
+		}
+	}
+	return {
+		sync,
+		merge,
+		syncFile,
+		scanRoot,
+		syncInline,
+		remove,
+		values,
+		valuesForEntries,
+		snapshot,
+		restore,
+		clear
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createSourceCandidateCollector", {
+	enumerable: true,
+	get: function() {
+		return createSourceCandidateCollector;
+	}
+});
+Object.defineProperty(exports, "isSourceCandidateRequest", {
+	enumerable: true,
+	get: function() {
+		return isSourceCandidateRequest;
+	}
+});