weapp-tailwindcss 5.0.13 → 5.1.0

package/dist/tailwindcss-DHIYcqXT.js

@@ -0,0 +1,1523 @@
+const require_chunk = require("./chunk-emK7D4bc.js");
+const require_v4_engine = require("./v4-engine-D4ubP7N5.js");
+require("./utils-BCa37Wqj.js");
+let node_fs = require("node:fs");
+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 _tailwindcss_mangle_engine = require("@tailwindcss-mangle/engine");
+let _weapp_tailwindcss_postcss = require("@weapp-tailwindcss/postcss");
+let node_fs_promises = require("node:fs/promises");
+let node_module = require("node:module");
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
+let fast_glob = require("fast-glob");
+fast_glob = require_chunk.__toESM(fast_glob);
+let tailwindcss_config = require("tailwindcss-config");
+let node_url = require("node:url");
+//#region src/bundlers/vite/static-config-content.ts
+function skipWhitespaceAndComments(source, start) {
+	let index = start;
+	while (index < source.length) {
+		const char = source[index];
+		if (/\s/.test(char ?? "")) {
+			index += 1;
+			continue;
+		}
+		if (char === "/" && source[index + 1] === "/") {
+			index += 2;
+			while (index < source.length && source[index] !== "\n") index += 1;
+			continue;
+		}
+		if (char === "/" && source[index + 1] === "*") {
+			index += 2;
+			while (index < source.length && !(source[index] === "*" && source[index + 1] === "/")) index += 1;
+			index = Math.min(index + 2, source.length);
+			continue;
+		}
+		break;
+	}
+	return index;
+}
+function readQuotedString(source, start) {
+	const quote = source[start];
+	if (quote !== "\"" && quote !== "'") return;
+	let value = "";
+	for (let index = start + 1; index < source.length; index++) {
+		const char = source[index];
+		if (char === "\\") {
+			const next = source[index + 1];
+			if (next === void 0) return;
+			value += next;
+			index += 1;
+			continue;
+		}
+		if (char === quote) return {
+			end: index + 1,
+			value
+		};
+		value += char;
+	}
+}
+function readIdentifier(source, start) {
+	return /^[A-Z_$][\w$]*/i.exec(source.slice(start))?.[0];
+}
+function findMatchingBracket(source, start, open, close) {
+	let depth = 0;
+	let quote;
+	for (let index = start; index < source.length; index++) {
+		const char = source[index];
+		if (char === "\\") {
+			index += 1;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "`") return;
+		if (char === open) {
+			depth += 1;
+			continue;
+		}
+		if (char === close) {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+}
+function findContentPropertyValue(source) {
+	let index = 0;
+	while (index < source.length) {
+		const nextIndex = source.indexOf("content", index);
+		if (nextIndex === -1) return;
+		const previous = source[nextIndex - 1];
+		const next = source[nextIndex + 7];
+		if (previous && /[\w$]/.test(previous) || next && /[\w$]/.test(next)) {
+			index = nextIndex + 7;
+			continue;
+		}
+		let colonIndex = skipWhitespaceAndComments(source, nextIndex + 7);
+		if (source[colonIndex] !== ":") {
+			index = nextIndex + 7;
+			continue;
+		}
+		colonIndex = skipWhitespaceAndComments(source, colonIndex + 1);
+		return { start: colonIndex };
+	}
+}
+function parseStaticContentArray(source, start) {
+	if (source[start] !== "[") return;
+	const value = [];
+	let index = skipWhitespaceAndComments(source, start + 1);
+	while (index < source.length) {
+		if (source[index] === "]") return {
+			end: index + 1,
+			value
+		};
+		const parsed = parseStaticContentValue(source, index);
+		if (!parsed) return;
+		value.push(parsed.value);
+		index = skipWhitespaceAndComments(source, parsed.end);
+		if (source[index] === ",") {
+			index = skipWhitespaceAndComments(source, index + 1);
+			continue;
+		}
+		if (source[index] === "]") continue;
+		return;
+	}
+}
+function parseStaticContentObject(source, start) {
+	if (source[start] !== "{") return;
+	const end = findMatchingBracket(source, start, "{", "}");
+	if (end === void 0) return;
+	let index = skipWhitespaceAndComments(source, start + 1);
+	let files;
+	while (index < end) {
+		let key;
+		const quotedKey = readQuotedString(source, index);
+		if (quotedKey) {
+			key = quotedKey.value;
+			index = quotedKey.end;
+		} else {
+			key = readIdentifier(source, index);
+			if (!key) return;
+			index += key.length;
+		}
+		index = skipWhitespaceAndComments(source, index);
+		if (source[index] !== ":") return;
+		index = skipWhitespaceAndComments(source, index + 1);
+		const parsedValue = parseStaticContentValue(source, index);
+		if (!parsedValue) return;
+		if (key === "files") files = parsedValue.value;
+		index = skipWhitespaceAndComments(source, parsedValue.end);
+		if (source[index] === ",") {
+			index = skipWhitespaceAndComments(source, index + 1);
+			continue;
+		}
+		if (index < end) return;
+	}
+	return files === void 0 ? void 0 : {
+		end: end + 1,
+		value: { files }
+	};
+}
+function parseStaticContentValue(source, start) {
+	const index = skipWhitespaceAndComments(source, start);
+	const quoted = readQuotedString(source, index);
+	if (quoted) return quoted;
+	if (source[index] === "[") return parseStaticContentArray(source, index);
+	if (source[index] === "{") return parseStaticContentObject(source, index);
+}
+function readStaticConfigContent(configPath) {
+	let source;
+	try {
+		source = (0, node_fs.readFileSync)(configPath, "utf8");
+	} catch {
+		return;
+	}
+	const contentProperty = findContentPropertyValue(source);
+	if (!contentProperty) return;
+	return parseStaticContentValue(source, contentProperty.start)?.value;
+}
+//#endregion
+//#region src/bundlers/vite/source-scan/css-entries.ts
+const VITE_SOURCE_CANDIDATE_PATTERN = require_v4_engine.FULL_SOURCE_SCAN_PATTERN;
+const VITE_TAILWIND_CSS_ENTRY_PATTERN = "**/*.css";
+const tailwindV4CssEntriesCache = /* @__PURE__ */ new Map();
+function parseImportSourceParam(params) {
+	const match = /\bsource\(\s*(none|(['"])(.*?)\2)\s*\)/.exec(params);
+	if (!match) return;
+	return {
+		none: match[1] === "none",
+		sourcePath: match[3]
+	};
+}
+function parseCssImportSpecifier(params) {
+	const value = params.trim();
+	const quoted = /^(['"])(.*?)\1/.exec(value);
+	if (quoted) return quoted[2];
+	const url = /^url\(\s*(?:(['"])(.*?)\1|([^'")\s]+))\s*\)/.exec(value);
+	return url?.[2] ?? url?.[3];
+}
+function isTailwindCssImport(params) {
+	const specifier = parseCssImportSpecifier(params);
+	return specifier === "tailwindcss" || specifier?.startsWith("tailwindcss/") || specifier?.replaceAll("\\", "/").endsWith("/tailwindcss/index.css");
+}
+function resolveSourceBase(base, sourcePath) {
+	return node_path.default.isAbsolute(sourcePath) ? sourcePath : node_path.default.resolve(base, sourcePath);
+}
+function resolveConfigPath(base, configPath) {
+	if (node_path.default.isAbsolute(configPath)) return node_path.default.resolve(configPath);
+	return node_path.default.resolve(base, configPath);
+}
+function createCssEntriesCacheKey(css, base, dependencies) {
+	return JSON.stringify({
+		base: node_path.default.resolve(base),
+		css,
+		dependencies
+	});
+}
+async function statConfigDependency(file) {
+	try {
+		const stats = await (0, node_fs_promises.stat)(file);
+		return {
+			file,
+			mtimeMs: stats.mtimeMs,
+			size: stats.size
+		};
+	} catch {
+		return {
+			file,
+			mtimeMs: -1,
+			size: -1
+		};
+	}
+}
+async function collectConfigDependencySignatures(root, base) {
+	const configPaths = /* @__PURE__ */ new Set();
+	root.walkAtRules("config", (rule) => {
+		const configPath = require_v4_engine.parseConfigParam(rule.params);
+		if (configPath) configPaths.add(resolveConfigPath(base, configPath));
+	});
+	return Promise.all([...configPaths].sort().map(statConfigDependency));
+}
+function mergeTailwindInlineSourceCandidates(allInlineCandidates) {
+	const merged = {
+		included: /* @__PURE__ */ new Set(),
+		excluded: /* @__PURE__ */ new Set()
+	};
+	for (const inlineCandidates of allInlineCandidates) {
+		if (!inlineCandidates) continue;
+		for (const candidate of inlineCandidates.included) if (!merged.excluded.has(candidate)) merged.included.add(candidate);
+		for (const candidate of inlineCandidates.excluded) {
+			merged.excluded.add(candidate);
+			merged.included.delete(candidate);
+		}
+	}
+	return merged.included.size > 0 || merged.excluded.size > 0 ? merged : void 0;
+}
+async function resolveConfigContentEntries(root, base) {
+	const configPaths = /* @__PURE__ */ new Set();
+	root.walkAtRules("config", (rule) => {
+		const configPath = require_v4_engine.parseConfigParam(rule.params);
+		if (configPath) configPaths.add(resolveConfigPath(base, configPath));
+	});
+	const entries = [];
+	for (const configPath of configPaths) {
+		const staticContent = readStaticConfigContent(configPath);
+		if (staticContent !== void 0) {
+			entries.push(...require_v4_engine.normalizeLegacyContentEntries(staticContent, node_path.default.dirname(configPath), { relativeBase: node_path.default.dirname(configPath) }));
+			continue;
+		}
+		try {
+			const loaded = await (0, tailwindcss_config.loadConfig)({
+				config: configPath,
+				cwd: node_path.default.dirname(configPath)
+			});
+			entries.push(...require_v4_engine.normalizeLegacyContentEntries(loaded?.config.content, node_path.default.dirname(configPath), { relativeBase: node_path.default.dirname(configPath) }));
+		} catch {}
+	}
+	return {
+		dependencies: [...configPaths],
+		entries
+	};
+}
+async function resolveTailwindV4EntriesFromCss(css, base) {
+	let root;
+	try {
+		root = _weapp_tailwindcss_postcss.postcss.parse(css);
+	} catch {
+		return;
+	}
+	let importSourceBase;
+	let hasSourceNone = false;
+	let hasTailwindCssImport = false;
+	const [sourceEntries, configEntries] = await Promise.all([require_v4_engine.resolveCssSourceEntries(root, base, VITE_SOURCE_CANDIDATE_PATTERN), resolveConfigContentEntries(root, base)]);
+	const entries = [...configEntries.entries, ...sourceEntries];
+	const hasPositiveEntries = entries.some((entry) => !entry.negated);
+	const inlineCandidates = require_v4_engine.collectCssInlineSourceCandidates(root);
+	root.walkAtRules("import", (rule) => {
+		if (!isTailwindCssImport(rule.params)) return;
+		hasTailwindCssImport = true;
+		const sourceParam = parseImportSourceParam(rule.params);
+		if (sourceParam?.none) hasSourceNone = true;
+		if (sourceParam?.sourcePath) importSourceBase = resolveSourceBase(base, sourceParam.sourcePath);
+	});
+	if (importSourceBase) return {
+		entries: [{
+			base: importSourceBase,
+			negated: false,
+			pattern: VITE_SOURCE_CANDIDATE_PATTERN
+		}, ...entries],
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	if (hasSourceNone) return {
+		entries,
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	if (hasPositiveEntries) return {
+		entries,
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	if (inlineCandidates.included.size > 0 || inlineCandidates.excluded.size > 0) return {
+		entries: [],
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	return hasTailwindCssImport ? {
+		entries,
+		explicit: false,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	} : void 0;
+}
+async function resolveViteTailwindV4CssDependencies(css, base) {
+	return (await resolveTailwindV4EntriesFromCss(css, base))?.dependencies ?? [];
+}
+function collectExistingCssEntries(options) {
+	return [
+		...options.cssEntries ?? [],
+		...options.tailwindcss?.v4?.cssEntries ?? [],
+		...options.tailwindcssRuntimeOptions?.tailwindcss?.v4?.cssEntries ?? []
+	].filter((item) => typeof item === "string" && item.length > 0).filter(require_v4_engine.isTailwindV4CssEntry).map((item) => node_path.default.resolve(item)).filter((item) => (0, node_fs.existsSync)(item));
+}
+async function pathExistsAsFile(file) {
+	try {
+		return (await (0, node_fs_promises.stat)(file)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindV4EntriesFromCssCached(css, base) {
+	let root;
+	try {
+		root = _weapp_tailwindcss_postcss.postcss.parse(css);
+	} catch {
+		return;
+	}
+	const cacheKey = createCssEntriesCacheKey(css, base, await collectConfigDependencySignatures(root, base));
+	const cached = tailwindV4CssEntriesCache.get(cacheKey);
+	if (cached) return cached;
+	const task = resolveTailwindV4EntriesFromCss(css, base).catch((error) => {
+		tailwindV4CssEntriesCache.delete(cacheKey);
+		throw error;
+	});
+	tailwindV4CssEntriesCache.set(cacheKey, task);
+	return task;
+}
+async function discoverTailwindV4CssEntries(root, outDir) {
+	const resolvedRoot = node_path.default.resolve(root);
+	const ignore = ["**/node_modules/**", "**/.git/**"];
+	const resolvedOutDir = outDir ? node_path.default.resolve(resolvedRoot, outDir) : void 0;
+	if (resolvedOutDir) {
+		const relativeOutDir = node_path.default.relative(resolvedRoot, resolvedOutDir);
+		if (relativeOutDir && !relativeOutDir.startsWith("..") && !node_path.default.isAbsolute(relativeOutDir)) ignore.push(`${relativeOutDir.split(node_path.default.sep).join("/")}/**`);
+	}
+	const candidates = await (0, fast_glob.default)(VITE_TAILWIND_CSS_ENTRY_PATTERN, {
+		absolute: true,
+		cwd: resolvedRoot,
+		ignore,
+		onlyFiles: true,
+		unique: true
+	});
+	const entries = [];
+	for (const file of candidates) {
+		if (!await pathExistsAsFile(file)) continue;
+		try {
+			const css = (0, node_fs.readFileSync)(file, "utf8");
+			if (css.includes("tailwindcss") || css.includes("@source") || css.includes("@config")) {
+				if (await resolveTailwindV4EntriesFromCssCached(css, node_path.default.dirname(file))) entries.push(file);
+			}
+		} catch {}
+	}
+	return entries;
+}
+function collectConfiguredCssSources(options) {
+	return require_v4_engine.filterTailwindV4CssSourceRoots([...options.tailwindcss?.v4?.cssSources ?? [], ...options.tailwindcssRuntimeOptions?.tailwindcss?.v4?.cssSources ?? []]) ?? [];
+}
+//#endregion
+//#region src/bundlers/vite/source-scan/dependencies.ts
+function addSourceScanDependency(dependencies, file) {
+	if (typeof file === "string" && file.length > 0) dependencies.add(node_path.default.resolve(file));
+}
+function addSourceScanDependencies(dependencies, files) {
+	for (const file of files ?? []) addSourceScanDependency(dependencies, file);
+}
+//#endregion
+//#region src/bundlers/vite/source-scan.ts
+function createResolvedViteSourceScan(input, dependencies) {
+	return {
+		...input,
+		...dependencies.size > 0 ? { dependencies: [...dependencies].sort() } : {}
+	};
+}
+function createMergedCssEntrySourceScanEntries(entries, options) {
+	if (options.sourceCount <= 1) return entries;
+	const positiveEntries = entries.filter((entry) => !entry.negated);
+	return positiveEntries.length > 0 ? positiveEntries : entries;
+}
+function createResolvedV4CssScanInput(entries, inlineCandidates, explicit) {
+	return {
+		entries: explicit ? entries : entries.length > 0 ? entries : void 0,
+		explicit,
+		inlineCandidates
+	};
+}
+async function resolveViteSourceScanEntries(options, runtime, scanOptions = {}) {
+	const sourceOptions = require_v4_engine.resolveTailwindV4SourceOptionsFromRuntime(runtime);
+	const cssEntries = collectExistingCssEntries(options);
+	if (cssEntries.length === 0 && !sourceOptions.css && !sourceOptions.cssSources?.length) {
+		const scanRoot = scanOptions.root;
+		const sourceProjectRoot = sourceOptions.projectRoot;
+		if (scanRoot && sourceProjectRoot && node_path.default.resolve(scanRoot) === node_path.default.resolve(sourceProjectRoot)) {
+			const discoveredCssEntries = await discoverTailwindV4CssEntries(scanRoot, scanOptions.outDir);
+			cssEntries.push(...discoveredCssEntries);
+		}
+	}
+	const entries = [];
+	const cssInlineCandidates = [];
+	const dependencies = /* @__PURE__ */ new Set();
+	let explicit = false;
+	let readableCssEntryCount = 0;
+	for (const cssEntry of cssEntries) {
+		addSourceScanDependency(dependencies, cssEntry);
+		let css;
+		try {
+			css = (0, node_fs.readFileSync)(cssEntry, "utf8");
+		} catch {
+			continue;
+		}
+		readableCssEntryCount++;
+		const resolved = await resolveTailwindV4EntriesFromCssCached(css, node_path.default.dirname(cssEntry));
+		if (resolved) {
+			entries.push(...resolved.entries);
+			cssInlineCandidates.push(resolved.inlineCandidates);
+			addSourceScanDependencies(dependencies, resolved.dependencies);
+			explicit || (explicit = resolved.explicit);
+		}
+	}
+	const inlineCandidates = mergeTailwindInlineSourceCandidates(cssInlineCandidates);
+	const scanEntries = createMergedCssEntrySourceScanEntries(entries, { sourceCount: readableCssEntryCount });
+	if (scanEntries.length > 0 || inlineCandidates || explicit || readableCssEntryCount > 0) return createResolvedViteSourceScan({
+		entries: explicit ? scanEntries : scanEntries.length > 0 ? scanEntries : void 0,
+		explicit,
+		inlineCandidates
+	}, dependencies);
+	if (typeof sourceOptions.css === "string" && sourceOptions.css.length > 0) {
+		const resolved = await resolveTailwindV4EntriesFromCssCached(sourceOptions.css, sourceOptions.base ?? sourceOptions.projectRoot ?? node_process.default.cwd());
+		return resolved ? createResolvedViteSourceScan(createResolvedV4CssScanInput(resolved.entries, resolved.inlineCandidates, resolved.explicit), new Set(resolved.dependencies)) : void 0;
+	}
+	const sourceOptionBase = sourceOptions.base ?? sourceOptions.projectRoot ?? node_process.default.cwd();
+	const configuredCssSources = collectConfiguredCssSources(options);
+	for (const cssSource of [...configuredCssSources, ...sourceOptions.cssSources ?? []]) {
+		if (typeof cssSource.css !== "string" || cssSource.css.length === 0) continue;
+		addSourceScanDependency(dependencies, cssSource.file);
+		addSourceScanDependencies(dependencies, cssSource.dependencies);
+		const resolved = await resolveTailwindV4EntriesFromCssCached(cssSource.css, require_v4_engine.resolveTailwindV4CssSourceBase(cssSource, sourceOptionBase));
+		if (resolved) {
+			entries.push(...resolved.entries);
+			cssInlineCandidates.push(resolved.inlineCandidates);
+			addSourceScanDependencies(dependencies, resolved.dependencies);
+			explicit || (explicit = resolved.explicit);
+		}
+	}
+	const cssSourceInlineCandidates = mergeTailwindInlineSourceCandidates(cssInlineCandidates);
+	const cssSourceScanEntries = createMergedCssEntrySourceScanEntries(entries, { sourceCount: (sourceOptions.cssSources?.length ?? 0) + configuredCssSources.length });
+	if (cssSourceScanEntries.length > 0 || cssSourceInlineCandidates || explicit || sourceOptions.cssSources?.length || configuredCssSources.length > 0) return createResolvedViteSourceScan({
+		entries: explicit ? cssSourceScanEntries : cssSourceScanEntries.length > 0 ? cssSourceScanEntries : void 0,
+		explicit,
+		inlineCandidates: cssSourceInlineCandidates
+	}, dependencies);
+	const source = await require_v4_engine.resolveTailwindV4SourceFromRuntime(runtime);
+	addSourceScanDependency(dependencies, source.file);
+	addSourceScanDependencies(dependencies, source.dependencies);
+	const resolved = await resolveTailwindV4EntriesFromCssCached(source.css, source.base);
+	return resolved ? createResolvedViteSourceScan(createResolvedV4CssScanInput(resolved.entries.length > 0 ? resolved.entries : [], resolved.inlineCandidates, resolved.entries.length > 0 ? resolved.explicit : false), new Set([...dependencies, ...resolved.dependencies])) : void 0;
+}
+function createViteSourceScanMatcher(entries) {
+	if (entries?.length === 0) return;
+	return require_v4_engine.createTailwindSourceEntryMatcher(entries);
+}
+//#endregion
+//#region src/tailwindcss/runtime/cache.ts
+const runtimeClassSetCache = /* @__PURE__ */ new WeakMap();
+const runtimeFileSignatureCache = /* @__PURE__ */ new Map();
+const runtimeTrackedSourceFilesCache = /* @__PURE__ */ new Map();
+let runtimeFileSignatureCacheClearTimer;
+const runtimeSignatureRuntimesSymbol = Symbol.for("weapp-tailwindcss.runtimeSignatureRuntimes");
+function getCacheEntry(tailwindRuntime) {
+	let entry = runtimeClassSetCache.get(tailwindRuntime);
+	if (!entry) {
+		entry = {};
+		runtimeClassSetCache.set(tailwindRuntime, entry);
+	}
+	return entry;
+}
+function scheduleRuntimeConfigSignatureCacheClear() {
+	if (runtimeFileSignatureCacheClearTimer) return;
+	runtimeFileSignatureCacheClearTimer = setTimeout(() => {
+		runtimeFileSignatureCache.clear();
+		runtimeTrackedSourceFilesCache.clear();
+		runtimeFileSignatureCacheClearTimer = void 0;
+	}, 0);
+	runtimeFileSignatureCacheClearTimer.unref?.();
+}
+function getFileSignature(filePath) {
+	const cached = runtimeFileSignatureCache.get(filePath);
+	if (cached !== void 0) return cached;
+	let signature;
+	try {
+		const stats = (0, node_fs.statSync)(filePath);
+		signature = `${filePath}:${stats.size}:${stats.mtimeMs}`;
+	} catch {
+		signature = `${filePath}:missing`;
+	}
+	runtimeFileSignatureCache.set(filePath, signature);
+	scheduleRuntimeConfigSignatureCacheClear();
+	return signature;
+}
+function getTailwindTrackedFiles(tailwindRuntime) {
+	const tailwindOptions = require_v4_engine.resolveTailwindcssOptions(tailwindRuntime.options);
+	const tracked = /* @__PURE__ */ new Set();
+	const configPath = tailwindOptions?.config;
+	if (typeof configPath === "string" && configPath.length > 0) tracked.add(configPath);
+	for (const entry of tailwindOptions?.v4?.cssEntries ?? []) if (typeof entry === "string" && entry.length > 0) tracked.add(entry);
+	for (const source of tailwindOptions?.v4?.cssSources ?? []) {
+		if (typeof source.file === "string" && source.file.length > 0) tracked.add(source.file);
+		for (const dependency of source.dependencies ?? []) if (typeof dependency === "string" && dependency.length > 0) tracked.add(dependency);
+	}
+	return tracked;
+}
+function normalizeTrackedSourceSignature(cssEntries, cssSources) {
+	return normalizeSignatureValue({
+		cssEntries: cssEntries?.map((entry) => {
+			if (!(0, node_fs.existsSync)(entry)) return `${entry}:missing`;
+			return getFileSignature(entry);
+		}),
+		cssSources
+	});
+}
+async function collectTailwindV4TrackedSourceFiles(tailwindRuntime) {
+	const tailwindOptions = require_v4_engine.resolveTailwindcssOptions(tailwindRuntime.options);
+	const signature = normalizeTrackedSourceSignature(tailwindOptions?.v4?.cssEntries, tailwindOptions?.v4?.cssSources);
+	const cached = runtimeTrackedSourceFilesCache.get(signature);
+	if (cached) return cached;
+	const files = /* @__PURE__ */ new Set();
+	for (const cssEntry of tailwindOptions?.v4?.cssEntries ?? []) {
+		if (!(0, node_fs.existsSync)(cssEntry)) continue;
+		const resolved = await resolveTailwindV4EntriesFromCssCached((0, node_fs.readFileSync)(cssEntry, "utf8"), node_path.default.dirname(cssEntry));
+		const expanded = resolved?.entries?.length ? await require_v4_engine.expandTailwindSourceEntries(resolved.entries) : [];
+		for (const file of expanded) files.add(file);
+	}
+	for (const cssSource of tailwindOptions?.v4?.cssSources ?? []) {
+		if (typeof cssSource.css !== "string" || cssSource.css.length === 0) continue;
+		const base = typeof cssSource.file === "string" && cssSource.file.length > 0 ? node_path.default.dirname(cssSource.file) : tailwindOptions?.v4?.base ?? tailwindOptions?.cwd ?? tailwindRuntime.options?.projectRoot ?? node_process.default.cwd();
+		const resolved = await resolveTailwindV4EntriesFromCssCached(cssSource.css, base);
+		const expanded = resolved?.entries?.length ? await require_v4_engine.expandTailwindSourceEntries(resolved.entries) : [];
+		for (const file of expanded) files.add(file);
+	}
+	const result = [...files].sort((a, b) => a.localeCompare(b));
+	runtimeTrackedSourceFilesCache.set(signature, result);
+	return result;
+}
+function normalizeSignatureValue(value) {
+	if (value == null) return "null";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	if (Array.isArray(value)) return `[${value.map((item) => normalizeSignatureValue(item)).join(",")}]`;
+	if (typeof value === "object") return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${key}:${normalizeSignatureValue(item)}`).join(",")}}`;
+	return String(value);
+}
+function readOptionalProperty(value, key) {
+	if (typeof value !== "object" || value === null || !(key in value)) return;
+	return value[key];
+}
+function getTailwindOptionsSignature(tailwindRuntime) {
+	const options = tailwindRuntime.options;
+	const tailwindOptions = require_v4_engine.resolveTailwindcssOptions(options);
+	return normalizeSignatureValue({
+		projectRoot: options?.projectRoot,
+		packageName: tailwindOptions?.packageName,
+		versionHint: readOptionalProperty(tailwindOptions, "versionHint"),
+		cwd: tailwindOptions?.cwd,
+		config: tailwindOptions?.config,
+		v4: {
+			base: tailwindOptions?.v4?.base,
+			configuredBase: readOptionalProperty(tailwindOptions?.v4, "configuredBase"),
+			css: tailwindOptions?.v4?.css,
+			cssEntries: tailwindOptions?.v4?.cssEntries,
+			cssSources: tailwindOptions?.v4?.cssSources,
+			hasUserDefinedSources: readOptionalProperty(tailwindOptions?.v4, "hasUserDefinedSources"),
+			sources: tailwindOptions?.v4?.sources
+		}
+	});
+}
+function getRuntimeTargetSignature(tailwindRuntime) {
+	const packageInfo = tailwindRuntime.packageInfo;
+	return [
+		packageInfo?.name ?? "missing",
+		packageInfo?.rootPath ?? "missing",
+		packageInfo?.version ?? "unknown",
+		tailwindRuntime.majorVersion ?? "unknown",
+		getTailwindOptionsSignature(tailwindRuntime)
+	].join(":");
+}
+function getNestedRuntimes(tailwindRuntime) {
+	const nested = tailwindRuntime[runtimeSignatureRuntimesSymbol];
+	return Array.isArray(nested) && nested.length > 0 ? nested : void 0;
+}
+function getOwnRuntimeClassSetSignature(tailwindRuntime) {
+	const trackedFiles = [...getTailwindTrackedFiles(tailwindRuntime)].sort((a, b) => a.localeCompare(b)).map(getFileSignature);
+	return `${trackedFiles.length > 0 ? trackedFiles.join("|") : "files:missing"}|runtime:${getRuntimeTargetSignature(tailwindRuntime)}`;
+}
+function invalidateRuntimeClassSet(tailwindRuntime) {
+	if (!tailwindRuntime) return;
+	const nestedRuntimes = getNestedRuntimes(tailwindRuntime);
+	if (nestedRuntimes) for (const runtime of nestedRuntimes) invalidateRuntimeClassSet(runtime);
+	for (const trackedFile of getTailwindTrackedFiles(tailwindRuntime)) runtimeFileSignatureCache.delete(trackedFile);
+	runtimeTrackedSourceFilesCache.clear();
+	runtimeClassSetCache.delete(tailwindRuntime);
+}
+function getRuntimeClassSetCacheEntry(tailwindRuntime) {
+	return getCacheEntry(tailwindRuntime);
+}
+function getRuntimeClassSetSignature(tailwindRuntime) {
+	const nestedRuntimes = getNestedRuntimes(tailwindRuntime);
+	if (nestedRuntimes) return nestedRuntimes.map(getOwnRuntimeClassSetSignature).sort((a, b) => a.localeCompare(b)).join("||");
+	return getOwnRuntimeClassSetSignature(tailwindRuntime);
+}
+async function getRuntimeClassSetSignatureWithSources(tailwindRuntime) {
+	const baseSignature = getRuntimeClassSetSignature(tailwindRuntime);
+	const trackedSourceFiles = await collectTailwindV4TrackedSourceFiles(tailwindRuntime);
+	if (trackedSourceFiles.length === 0) return baseSignature;
+	return [baseSignature, trackedSourceFiles.map(getFileSignature).join("|")].join("|sources:");
+}
+//#endregion
+//#region src/tailwindcss/v4/config.ts
+const DEFAULT_CSS_CALC_CUSTOM_PROPERTIES = [];
+function includesToken(list, token) {
+	return list.some((candidate) => {
+		if (typeof token === "string") {
+			if (typeof candidate === "string") return candidate === token;
+			candidate.lastIndex = 0;
+			return candidate.test(token);
+		}
+		if (typeof candidate === "string") {
+			token.lastIndex = 0;
+			return token.test(candidate);
+		}
+		return candidate.source === token.source && candidate.flags === token.flags;
+	});
+}
+function ensureDefaultsIncluded(value) {
+	if (value === true) return { includeCustomProperties: [...DEFAULT_CSS_CALC_CUSTOM_PROPERTIES] };
+	if (Array.isArray(value)) {
+		if (!DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.length) return value;
+		const missing = DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.filter((token) => !includesToken(value, token));
+		return missing.length > 0 ? [...value, ...missing] : value;
+	}
+	if (value && typeof value === "object") {
+		const include = value.includeCustomProperties;
+		if (!Array.isArray(include)) return {
+			...value,
+			includeCustomProperties: [...DEFAULT_CSS_CALC_CUSTOM_PROPERTIES]
+		};
+		if (!DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.length) return value;
+		const missing = DEFAULT_CSS_CALC_CUSTOM_PROPERTIES.filter((token) => !includesToken(include, token));
+		return missing.length > 0 ? {
+			...value,
+			includeCustomProperties: [...include, ...missing]
+		} : value;
+	}
+	return value;
+}
+function normalizeCssEntriesConfig(entries) {
+	const normalized = require_v4_engine.normalizeStringListOption(entries)?.filter(require_v4_engine.isTailwindV4CssEntry);
+	return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function hasConfiguredCssEntries(ctx) {
+	if (normalizeCssEntriesConfig(ctx.cssEntries)) return true;
+	if (normalizeCssEntriesConfig(ctx.tailwindcss?.v4?.cssEntries)) return true;
+	const runtimeOptions = ctx.tailwindcssRuntimeOptions;
+	if (runtimeOptions) {
+		if (normalizeCssEntriesConfig(runtimeOptions.tailwindcss?.v4?.cssEntries)) return true;
+	}
+	return false;
+}
+let hasWarnedMissingCssEntries = false;
+function warnMissingCssEntries(ctx, tailwindRuntime) {
+	if (hasWarnedMissingCssEntries) return;
+	if (!tailwindRuntime) return;
+	if (hasConfiguredCssEntries(ctx) || require_v4_engine.hasConfiguredTailwindV4CssRoots(ctx)) return;
+	hasWarnedMissingCssEntries = true;
+	_weapp_tailwindcss_logger.logger.warn("[tailwindcss@4] 未检测到 cssEntries 配置。请传入包含 tailwindcss 引用的 CSS 绝对路径，例如 cssEntries: [\"/absolute/path/to/src/app.css\"]，否则 tailwindcss 生成的类名不会参与转译。");
+}
+function applyV4CssCalcDefaults(cssCalc, tailwindRuntime) {
+	const cssCalcOptions = cssCalc ?? true;
+	if (tailwindRuntime && cssCalcOptions) return ensureDefaultsIncluded(cssCalcOptions);
+	return cssCalcOptions;
+}
+//#endregion
+//#region src/tailwindcss/runtime-resolve.ts
+const GENERIC_RELATIVE_SPECIFIERS = [".", ".."];
+const DEFAULT_TAILWIND_CONFIG_SPECIFIERS = ["stubs/config.full.js", "defaultConfig.js"];
+const TAILWIND_CONFIG_FILES = [
+	"tailwind.config.js",
+	"tailwind.config.cjs",
+	"tailwind.config.mjs",
+	"tailwind.config.ts",
+	"tailwind.config.cts",
+	"tailwind.config.mts"
+];
+function isPathSpecifier(specifier) {
+	if (!specifier) return false;
+	if (specifier.startsWith("file://")) return true;
+	if (node_path.default.isAbsolute(specifier)) return true;
+	return GENERIC_RELATIVE_SPECIFIERS.some((prefix) => specifier.startsWith(`${prefix}/`) || specifier.startsWith(`${prefix}\\`));
+}
+function resolveModuleFromPaths(specifier, paths) {
+	if (!specifier || isPathSpecifier(specifier) || paths.length === 0) return;
+	try {
+		return (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve(specifier, { paths });
+	} catch {
+		return;
+	}
+}
+function resolveTailwindConfigFallback(packageName, paths) {
+	if (!packageName) return;
+	for (const suffix of DEFAULT_TAILWIND_CONFIG_SPECIFIERS) {
+		const resolved = resolveModuleFromPaths(`${packageName}/${suffix}`, paths);
+		if (resolved) return resolved;
+	}
+}
+function appendNodeModules(paths, dir) {
+	if (!dir) return;
+	const nodeModulesDir = node_path.default.join(dir, "node_modules");
+	if ((0, node_fs.existsSync)(nodeModulesDir)) paths.add(nodeModulesDir);
+}
+function findTailwindConfig(searchRoots) {
+	for (const root of searchRoots) for (const file of TAILWIND_CONFIG_FILES) {
+		const candidate = node_path.default.resolve(root, file);
+		if ((0, node_fs.existsSync)(candidate)) return candidate;
+	}
+}
+function createDefaultResolvePaths(basedir) {
+	const paths = /* @__PURE__ */ new Set();
+	let fallbackCandidates = [];
+	if (basedir) {
+		const resolvedBase = node_path.default.resolve(basedir);
+		appendNodeModules(paths, resolvedBase);
+		fallbackCandidates.push(resolvedBase);
+		const packageRoot = require_v4_engine.findNearestPackageRoot(resolvedBase);
+		if (packageRoot) {
+			appendNodeModules(paths, packageRoot);
+			fallbackCandidates.push(packageRoot);
+		}
+		const workspaceRoot = require_v4_engine.findWorkspaceRoot(resolvedBase);
+		if (workspaceRoot) {
+			appendNodeModules(paths, workspaceRoot);
+			fallbackCandidates.push(workspaceRoot);
+		}
+	}
+	const cwd = node_process.default.cwd();
+	appendNodeModules(paths, cwd);
+	try {
+		const modulePath = (0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+		const candidate = (0, node_fs.existsSync)(modulePath) && !node_path.default.extname(modulePath) ? modulePath : node_path.default.dirname(modulePath);
+		paths.add(candidate);
+	} catch {
+		paths.add(require("url").pathToFileURL(__filename).href);
+	}
+	if (paths.size === 0) {
+		fallbackCandidates = fallbackCandidates.filter(Boolean);
+		if (fallbackCandidates.length === 0) fallbackCandidates.push(cwd);
+		for (const candidate of fallbackCandidates) paths.add(candidate);
+	}
+	return [...paths];
+}
+//#endregion
+//#region src/tailwindcss/version.ts
+function normalizeSupportedTailwindcssMajorVersion(version) {
+	return version === 4 ? version : void 0;
+}
+function readPackageJson(packageJsonPath) {
+	try {
+		return JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findPackageJsonDeclaringPackage(packageName, base) {
+	let current = node_path.default.resolve(base);
+	while (true) {
+		const pkgPath = node_path.default.join(current, "package.json");
+		if ((0, node_fs.existsSync)(pkgPath)) {
+			const pkg = readPackageJson(pkgPath);
+			if (readDeclaredPackageVersion(packageName, pkg)) return pkgPath;
+			if (pkg?.name !== "weapp-tailwindcss") return;
+		}
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function readDeclaredPackageVersion(packageName, pkg) {
+	return pkg?.dependencies?.[packageName] ?? pkg?.devDependencies?.[packageName] ?? pkg?.peerDependencies?.[packageName] ?? pkg?.optionalDependencies?.[packageName];
+}
+function readDeclaredPackageMajorVersion(version) {
+	const match = version?.match(/(?:^|\D)(4)(?:\.|\b)/);
+	return normalizeSupportedTailwindcssMajorVersion(match ? Number(match[1]) : void 0);
+}
+function readInstalledPackageMajorVersion(packageName, base) {
+	const packageJsonPath = findPackageJsonDeclaringPackage(packageName, base);
+	if (!packageJsonPath) return;
+	const declaredVersion = readDeclaredPackageVersion(packageName, readPackageJson(packageJsonPath));
+	if (!declaredVersion) return;
+	try {
+		const pkg = (0, node_module.createRequire)(packageJsonPath)(`${packageName}/package.json`);
+		return normalizeSupportedTailwindcssMajorVersion(Number(pkg.version?.split(".")[0]));
+	} catch {
+		return readDeclaredPackageMajorVersion(declaredVersion);
+	}
+}
+//#endregion
+//#region src/tailwindcss/runtime-factory.ts
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+function createPackageInfo(tailwindOptions) {
+	const packageName = tailwindOptions?.packageName ?? "tailwindcss";
+	const resolvePaths = tailwindOptions?.resolve?.paths;
+	let rootPath;
+	const cwdPackageJsonPath = tailwindOptions?.cwd ? node_path.default.join(tailwindOptions.cwd, "package.json") : void 0;
+	if (cwdPackageJsonPath) try {
+		if (require$1(cwdPackageJsonPath).name === packageName) rootPath = cwdPackageJsonPath;
+	} catch {}
+	rootPath ?? (rootPath = resolveModuleFromPaths(`${packageName}/package.json`, resolvePaths ?? []));
+	if (!rootPath) for (const resolvePath of [tailwindOptions?.cwd, ...resolvePaths ?? []]) {
+		if (!resolvePath) continue;
+		try {
+			rootPath = (0, node_module.createRequire)(node_path.default.join(resolvePath, "package.json")).resolve(`${packageName}/package.json`);
+			break;
+		} catch {}
+	}
+	if (rootPath) {
+		const packageJsonPath = rootPath;
+		const packageRoot = node_path.default.dirname(packageJsonPath);
+		try {
+			const packageJson = require$1(packageJsonPath);
+			return {
+				name: packageName,
+				version: packageJson.version,
+				rootPath: packageRoot,
+				packageJsonPath,
+				packageJson
+			};
+		} catch {
+			return {
+				name: packageName,
+				version: void 0,
+				rootPath: packageRoot,
+				packageJsonPath,
+				packageJson: {}
+			};
+		}
+	}
+	return {
+		name: packageName,
+		version: void 0,
+		rootPath: "",
+		packageJsonPath: "",
+		packageJson: {}
+	};
+}
+function resolveMajorVersion(tailwindOptions, packageInfo) {
+	if (tailwindOptions?.version === 4) return tailwindOptions.version;
+	if (packageInfo.version?.startsWith("4.")) return 4;
+	return 4;
+}
+function createFallbackTailwindcssRuntime(options) {
+	const packageInfo = createPackageInfo(options?.tailwindcss);
+	return {
+		packageInfo,
+		majorVersion: resolveMajorVersion(options?.tailwindcss, packageInfo),
+		options,
+		async getClassSet() {
+			return /* @__PURE__ */ new Set();
+		},
+		async extract(_options) {
+			return {
+				classList: [],
+				classSet: /* @__PURE__ */ new Set()
+			};
+		},
+		async collectContentTokens() {
+			return {
+				entries: [],
+				filesScanned: 0,
+				sources: [],
+				skippedFiles: []
+			};
+		}
+	};
+}
+function createEngineTailwindcssRuntime(options) {
+	const tailwindOptions = options.tailwindcss;
+	const packageInfo = createPackageInfo(tailwindOptions);
+	const majorVersion = resolveMajorVersion(tailwindOptions, packageInfo);
+	let classSetCache;
+	let runtime;
+	function applyClassSetFilter(classSet) {
+		if (typeof options.filter !== "function") return classSet;
+		return new Set([...classSet].filter((className) => options.filter?.(className) !== false));
+	}
+	async function collectClassSet() {
+		const report = await collectContentTokens();
+		const candidates = new Set(report.entries.map((entry) => {
+			return typeof entry === "string" ? entry : entry.rawCandidate;
+		}).filter((entry) => typeof entry === "string" && entry.length > 0));
+		await collectTailwindV4CssCandidates(candidates);
+		return applyClassSetFilter(candidates);
+	}
+	async function collectTailwindV4CssCandidates(candidates) {
+		const source = await require_v4_engine.resolveTailwindV4SourceFromRuntime(runtime);
+		const cssList = [source.css, ...(source.cssSources ?? []).map((cssSource) => cssSource.css).filter((css) => typeof css === "string")];
+		for (const css of cssList) {
+			if (!css.includes("@apply")) continue;
+			try {
+				_weapp_tailwindcss_postcss.postcss.parse(css).walkAtRules("apply", (rule) => {
+					for (const candidate of rule.params.split(/\s+/)) {
+						const normalized = candidate.replace(/!important$/, "").trim();
+						if (normalized) candidates.add(normalized);
+					}
+				});
+			} catch {}
+		}
+	}
+	async function collectContentTokens() {
+		const source = await require_v4_engine.resolveTailwindV4SourceFromRuntime(runtime);
+		const report = await (0, _tailwindcss_mangle_engine.extractProjectCandidatesWithPositions)({
+			base: source.base,
+			baseFallbacks: source.baseFallbacks,
+			css: source.css,
+			cwd: source.projectRoot,
+			sources: source.sources
+		});
+		return {
+			entries: report.entries,
+			filesScanned: report.filesScanned,
+			sources: source.sources,
+			skippedFiles: report.skippedFiles
+		};
+	}
+	async function extract(options) {
+		let classSet = await collectClassSet();
+		const filter = options?.removeUniversalSelector === true ? (className) => className !== "*" : void 0;
+		if (filter) classSet = new Set([...classSet].filter(filter));
+		if (typeof options?.write === "boolean") {}
+		classSetCache = classSet;
+		return {
+			classList: [...classSet],
+			classSet
+		};
+	}
+	runtime = {
+		packageInfo,
+		majorVersion,
+		options,
+		async getClassSet() {
+			return (await extract({ write: false })).classSet;
+		},
+		getClassSetSync() {
+			return classSetCache ?? /* @__PURE__ */ new Set();
+		},
+		extract,
+		collectContentTokens
+	};
+	return runtime;
+}
+let hasLoggedMissingTailwind = false;
+const TAILWINDCSS_NOT_FOUND_RE = /tailwindcss not found/i;
+const UNABLE_TO_LOCATE_TAILWINDCSS_RE = /unable to locate tailwind css package/i;
+function createTailwindcssRuntime(options) {
+	const { basedir, cacheDir, supportCustomLengthUnits, tailwindcss, tailwindcssRuntimeOptions } = options || {};
+	const cache = {
+		enabled: true,
+		driver: "memory"
+	};
+	const normalizedBasedir = basedir ? node_path.default.resolve(basedir) : void 0;
+	const cacheRoot = require_v4_engine.findNearestPackageRoot(normalizedBasedir) ?? normalizedBasedir ?? node_process.default.cwd();
+	if (cacheDir) if (node_path.default.isAbsolute(cacheDir)) cache.dir = cacheDir;
+	else if (normalizedBasedir) cache.dir = node_path.default.resolve(normalizedBasedir, cacheDir);
+	else cache.dir = node_path.default.resolve(node_process.default.cwd(), cacheDir);
+	else cache.dir = node_path.default.join(cacheRoot, "node_modules", ".cache", "@tailwindcss-mangle", "engine");
+	if (normalizedBasedir) cache.cwd = normalizedBasedir;
+	const resolvePaths = createDefaultResolvePaths(cache.cwd ?? normalizedBasedir ?? node_process.default.cwd());
+	const normalizedUserOptions = require_v4_engine.normalizeTailwindcssRuntimeOptions(tailwindcssRuntimeOptions);
+	const extendLengthUnits = require_v4_engine.normalizeExtendLengthUnits(supportCustomLengthUnits ?? true);
+	const baseTailwindOptions = (0, _weapp_tailwindcss_shared.defuOverrideArray)(tailwindcss ?? {}, require_v4_engine.omitUndefined({
+		cwd: normalizedBasedir,
+		resolve: { paths: resolvePaths }
+	}));
+	baseTailwindOptions.packageName = tailwindcss?.packageName ?? normalizedUserOptions?.tailwindcss?.packageName ?? baseTailwindOptions.packageName ?? "tailwindcss";
+	if (!baseTailwindOptions.postcssPlugin) baseTailwindOptions.postcssPlugin = "tailwindcss";
+	if (typeof baseTailwindOptions.postcssPlugin === "string") {
+		const resolvedPlugin = resolveModuleFromPaths(baseTailwindOptions.postcssPlugin, resolvePaths);
+		if (resolvedPlugin) baseTailwindOptions.postcssPlugin = resolvedPlugin;
+	}
+	const baseOptions = require_v4_engine.omitUndefined({
+		projectRoot: normalizedBasedir,
+		cache,
+		tailwindcss: baseTailwindOptions,
+		apply: require_v4_engine.omitUndefined({
+			exposeContext: true,
+			extendLengthUnits
+		})
+	});
+	const resolvedOptions = (0, _weapp_tailwindcss_shared.defuOverrideArray)(normalizedUserOptions ?? {}, baseOptions);
+	const resolvedTailwindOptions = resolvedOptions.tailwindcss;
+	if (resolvedTailwindOptions) {
+		const existingResolve = resolvedTailwindOptions.resolve ?? {};
+		const sourcePaths = Array.isArray(existingResolve.paths) && existingResolve.paths.length > 0 ? [...existingResolve.paths ?? [], ...resolvePaths] : resolvePaths;
+		resolvedTailwindOptions.resolve = {
+			...existingResolve,
+			paths: [...new Set(sourcePaths)]
+		};
+		_weapp_tailwindcss_logger.logger.debug("Tailwind resolve config %O", {
+			packageName: resolvedTailwindOptions.packageName,
+			version: resolvedTailwindOptions.version,
+			resolve: resolvedTailwindOptions.resolve,
+			cwd: resolvedTailwindOptions.cwd
+		});
+		if (typeof resolvedTailwindOptions.postcssPlugin === "string") {
+			const resolvedPlugin = resolveModuleFromPaths(resolvedTailwindOptions.postcssPlugin, resolvedTailwindOptions.resolve?.paths ?? resolvePaths);
+			if (resolvedPlugin) resolvedTailwindOptions.postcssPlugin = resolvedPlugin;
+		}
+		const searchRoots = /* @__PURE__ */ new Set();
+		if (resolvedTailwindOptions.cwd) searchRoots.add(resolvedTailwindOptions.cwd);
+		for (const resolvePath of resolvedTailwindOptions.resolve?.paths ?? []) {
+			const parentDir = node_path.default.dirname(resolvePath);
+			searchRoots.add(parentDir);
+		}
+		const configPath = findTailwindConfig(searchRoots);
+		if (!resolvedTailwindOptions.config) if (configPath) resolvedTailwindOptions.config = configPath;
+		else {
+			const fallbackConfig = resolveTailwindConfigFallback(resolvedTailwindOptions.packageName, resolvedTailwindOptions.resolve.paths ?? resolvePaths);
+			if (fallbackConfig) resolvedTailwindOptions.config = fallbackConfig;
+		}
+		if (!resolvedTailwindOptions.cwd && configPath) resolvedTailwindOptions.cwd = node_path.default.dirname(configPath);
+		resolvedOptions.tailwindcss = resolvedTailwindOptions;
+	}
+	try {
+		return createEngineTailwindcssRuntime(resolvedOptions);
+	} catch (error) {
+		const searchPaths = resolvedOptions.tailwindcss?.resolve?.paths;
+		if (error instanceof Error && TAILWINDCSS_NOT_FOUND_RE.test(error.message)) {
+			if (!hasLoggedMissingTailwind) {
+				_weapp_tailwindcss_logger.logger.warn("Tailwind CSS 未安装，已跳过 Tailwind 运行时能力。若需使用 Tailwind 能力，请安装 tailwindcss。");
+				hasLoggedMissingTailwind = true;
+			}
+			return createFallbackTailwindcssRuntime(resolvedOptions);
+		}
+		if (error instanceof Error && UNABLE_TO_LOCATE_TAILWINDCSS_RE.test(error.message)) _weapp_tailwindcss_logger.logger.error("无法定位 Tailwind CSS 包 \"%s\"，已尝试路径: %O", resolvedOptions.tailwindcss?.packageName, searchPaths);
+		throw error;
+	}
+}
+//#endregion
+//#region src/tailwindcss/v4/multi-runtime.ts
+function createMultiTailwindcssRuntime(runtimes) {
+	if (runtimes.length <= 1) {
+		const [runtime] = runtimes;
+		if (!runtime) throw new Error("createMultiTailwindcssRuntime requires at least one runtime.");
+		return runtime;
+	}
+	const first = runtimes[0];
+	const multiRuntime = {
+		...first,
+		packageInfo: first?.packageInfo,
+		majorVersion: first?.majorVersion,
+		options: first?.options,
+		async getClassSet() {
+			const aggregated = /* @__PURE__ */ new Set();
+			for (const runtime of runtimes) {
+				const current = await runtime.getClassSet();
+				for (const className of current) aggregated.add(className);
+			}
+			return aggregated;
+		},
+		async extract(options) {
+			const aggregatedSet = /* @__PURE__ */ new Set();
+			const aggregatedList = [];
+			let filename;
+			for (const runtime of runtimes) {
+				const result = await runtime.extract(options);
+				if (!result) continue;
+				if (filename === void 0 && result.filename) filename = result.filename;
+				if (result.classList) for (const className of result.classList) {
+					if (!aggregatedSet.has(className)) aggregatedList.push(className);
+					aggregatedSet.add(className);
+				}
+				if (result.classSet) for (const className of result.classSet) aggregatedSet.add(className);
+			}
+			return require_v4_engine.omitUndefined({
+				classList: aggregatedList,
+				classSet: aggregatedSet,
+				filename
+			});
+		}
+	};
+	if (runtimes.every((runtime) => typeof runtime.getClassSetSync === "function")) multiRuntime.getClassSetSync = () => {
+		const aggregated = /* @__PURE__ */ new Set();
+		for (const runtime of runtimes) {
+			const current = runtime.getClassSetSync?.();
+			if (!current) continue;
+			for (const className of current) aggregated.add(className);
+		}
+		return aggregated;
+	};
+	Object.defineProperty(multiRuntime, runtimeSignatureRuntimesSymbol, {
+		value: [...runtimes],
+		configurable: true
+	});
+	return multiRuntime;
+}
+//#endregion
+//#region src/tailwindcss/v4/runtime-options.ts
+function overrideTailwindcssRuntimeOptionsForBase(options, baseDir, cssEntries) {
+	const hasCssEntries = cssEntries.length > 0;
+	if (!options) return options;
+	const modernTailwind = options.tailwindcss;
+	if (!modernTailwind) return options;
+	return {
+		...options,
+		tailwindcss: {
+			...modernTailwind,
+			v4: {
+				...modernTailwind.v4 ?? {},
+				...hasCssEntries ? {} : { base: modernTailwind.v4?.base ?? baseDir },
+				cssEntries: hasCssEntries ? cssEntries : modernTailwind.v4?.cssEntries ?? cssEntries
+			}
+		}
+	};
+}
+//#endregion
+//#region src/tailwindcss/v4/runtime-factory.ts
+function isTailwindcss4Package(packageName) {
+	return Boolean(packageName && (packageName === "tailwindcss4" || packageName === "@tailwindcss/postcss" || packageName.includes("tailwindcss4")));
+}
+function resolveExplicitTailwindVersion(configuredVersion, configuredPackageName) {
+	if (typeof configuredVersion === "number") return configuredVersion;
+	if (isTailwindcss4Package(configuredPackageName)) return 4;
+}
+function readPackageNameFromBaseDir(baseDir) {
+	try {
+		if (!(0, node_fs.existsSync)(node_path.default.join(baseDir, "index.css"))) return;
+		const name = JSON.parse((0, node_fs.readFileSync)(node_path.default.join(baseDir, "package.json"), "utf8")).name;
+		return typeof name === "string" && (name === "tailwindcss" || name.includes("tailwindcss4")) ? name : void 0;
+	} catch {
+		return;
+	}
+}
+function createTailwindcssRuntimeForBase(baseDir, cssEntries, options) {
+	const { tailwindcss, tailwindcssRuntimeOptions, supportCustomLengthUnits, bareArbitraryValues } = options;
+	const hasCssEntries = Boolean(cssEntries?.length);
+	const defaultTailwindcssConfig = {
+		cwd: baseDir,
+		v4: hasCssEntries ? require_v4_engine.omitUndefined({ cssEntries }) : require_v4_engine.omitUndefined({
+			base: baseDir,
+			cssEntries
+		})
+	};
+	const mergedTailwindOptions = (0, _weapp_tailwindcss_shared.defuOverrideArray)(tailwindcss ?? {}, defaultTailwindcssConfig);
+	if (!mergedTailwindOptions.v4 || typeof mergedTailwindOptions.v4 !== "object") mergedTailwindOptions.v4 = hasCssEntries ? { cssEntries: cssEntries ?? [] } : {
+		base: baseDir,
+		cssEntries: cssEntries ?? []
+	};
+	else if (hasCssEntries) {
+		if (cssEntries?.length) mergedTailwindOptions.v4.cssEntries = cssEntries;
+		else if (!mergedTailwindOptions.v4.cssEntries) mergedTailwindOptions.v4.cssEntries = [];
+	} else if (!mergedTailwindOptions.v4.cssEntries) {
+		if (!mergedTailwindOptions.v4.base) mergedTailwindOptions.v4.base = baseDir;
+		mergedTailwindOptions.v4.cssEntries = cssEntries ?? [];
+	}
+	if (bareArbitraryValues !== void 0 && bareArbitraryValues !== false) mergedTailwindOptions.v4.bareArbitraryValues = bareArbitraryValues;
+	const patchedOptions = overrideTailwindcssRuntimeOptionsForBase(tailwindcssRuntimeOptions, baseDir, cssEntries ?? []);
+	const configuredPackageName = tailwindcss?.packageName || tailwindcssRuntimeOptions?.tailwindcss?.packageName;
+	const explicitTailwindVersion = resolveExplicitTailwindVersion(tailwindcss?.version || tailwindcssRuntimeOptions?.tailwindcss?.version || mergedTailwindOptions.version, configuredPackageName);
+	const resolvedTailwindVersion = readInstalledPackageMajorVersion(configuredPackageName ?? mergedTailwindOptions.packageName ?? "tailwindcss", baseDir) ?? explicitTailwindVersion;
+	const supportedResolvedTailwindVersion = resolvedTailwindVersion === 4 ? resolvedTailwindVersion : void 0;
+	const tailwindOptionsForPackage = {
+		...mergedTailwindOptions,
+		packageName: configuredPackageName ?? mergedTailwindOptions.packageName ?? readPackageNameFromBaseDir(baseDir) ?? "tailwindcss"
+	};
+	if (supportedResolvedTailwindVersion) tailwindOptionsForPackage.version = supportedResolvedTailwindVersion;
+	return createTailwindcssRuntime(require_v4_engine.omitUndefined({
+		basedir: baseDir,
+		supportCustomLengthUnits: supportCustomLengthUnits ?? true,
+		tailwindcss: tailwindOptionsForPackage,
+		tailwindcssRuntimeOptions: patchedOptions
+	}));
+}
+function tryCreateMultiTailwindcssRuntime(groups, options) {
+	if (groups.size <= 1) return;
+	_weapp_tailwindcss_logger.logger.debug("detected multiple Tailwind CSS entry bases: %O", [...groups.keys()]);
+	const runtimes = [];
+	for (const [baseDir, entries] of groups) {
+		const runtime = createTailwindcssRuntimeForBase(baseDir, entries, options);
+		if (runtime) runtimes.push(runtime);
+	}
+	return createMultiTailwindcssRuntime(runtimes);
+}
+//#endregion
+//#region src/uni-app-x/options.ts
+const DEFAULT_COMPONENT_LOCAL_STYLES_OPTIONS = {
+	enabled: true,
+	onlyWhenStyleIsolationVersion2: true
+};
+const DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS = {
+	enabled: false,
+	onlyWhenStyleIsolationVersion2: true
+};
+function isBooleanUniAppXShortcut(option) {
+	return option === true || option === false || option === void 0;
+}
+function resolveComponentLocalStyles(option) {
+	if (isBooleanUniAppXShortcut(option)) return DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS;
+	const componentLocalStyles = option.componentLocalStyles;
+	if (componentLocalStyles === false) return DISABLED_COMPONENT_LOCAL_STYLES_OPTIONS;
+	if (componentLocalStyles === true || componentLocalStyles === void 0) return DEFAULT_COMPONENT_LOCAL_STYLES_OPTIONS;
+	return {
+		enabled: componentLocalStyles.enabled !== false,
+		onlyWhenStyleIsolationVersion2: componentLocalStyles.onlyWhenStyleIsolationVersion2 !== false
+	};
+}
+function resolveUniAppXOptions(option) {
+	if (typeof option === "object" && option) return {
+		enabled: option.enabled !== false,
+		componentLocalStyles: resolveComponentLocalStyles(option),
+		uvueUnsupported: option.uvueUnsupported ?? "warn"
+	};
+	return {
+		enabled: Boolean(option),
+		componentLocalStyles: resolveComponentLocalStyles(option),
+		uvueUnsupported: "warn"
+	};
+}
+function isUniAppXEnabled(option) {
+	return resolveUniAppXOptions(option).enabled;
+}
+//#endregion
+//#region src/context/tailwindcss/basedir.ts
+const ENV_BASEDIR_KEYS = [
+	"WEAPP_TAILWINDCSS_BASEDIR",
+	"WEAPP_TAILWINDCSS_BASE_DIR",
+	"TAILWINDCSS_BASEDIR",
+	"TAILWINDCSS_BASE_DIR",
+	"UNI_INPUT_DIR",
+	"UNI_INPUT_ROOT",
+	"UNI_CLI_ROOT",
+	"UNI_APP_INPUT_DIR",
+	"INIT_CWD",
+	"PWD"
+];
+const GENERIC_ENV_BASEDIR_KEYS = new Set(["INIT_CWD", "PWD"]);
+function pickEnvBasedir() {
+	for (const key of ENV_BASEDIR_KEYS) {
+		const value = node_process.default.env[key];
+		if (value && node_path.default.isAbsolute(value)) return {
+			key,
+			value
+		};
+	}
+}
+function pickPackageEnvBasedir() {
+	const packageJsonPath = node_process.default.env["npm_package_json"];
+	if (packageJsonPath) {
+		const packageDir = node_path.default.dirname(packageJsonPath);
+		if (packageDir && node_path.default.isAbsolute(packageDir)) return packageDir;
+	}
+	const localPrefix = node_process.default.env["npm_config_local_prefix"];
+	if (localPrefix && node_path.default.isAbsolute(localPrefix)) return localPrefix;
+}
+const STACK_PAREN_RE = /\(([^)]+)\)/u;
+const STACK_AT_RE = /at\s+(\S.*)$/u;
+function detectCallerBasedir() {
+	const stack = (/* @__PURE__ */ new Error("resolveTailwindcssBasedir stack probe")).stack;
+	if (!stack) return;
+	if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("caller stack: %s", stack);
+	const lines = stack.split("\n");
+	for (const line of lines) {
+		const location = (line.match(STACK_PAREN_RE) ?? line.match(STACK_AT_RE))?.[1];
+		if (!location) continue;
+		let filePath = location;
+		if (filePath.startsWith("file://")) try {
+			filePath = (0, node_url.fileURLToPath)(filePath);
+		} catch {
+			continue;
+		}
+		const [candidate = ""] = filePath.split(":");
+		const resolvedPath = node_path.default.isAbsolute(filePath) ? filePath : candidate;
+		if (!node_path.default.isAbsolute(resolvedPath)) continue;
+		if (resolvedPath.includes("node_modules") && resolvedPath.includes("weapp-tailwindcss")) continue;
+		try {
+			return node_path.default.dirname(resolvedPath);
+		} catch {
+			continue;
+		}
+	}
+}
+function resolveTailwindcssBasedir(basedir, fallback) {
+	const envBasedirResult = pickEnvBasedir();
+	const envBasedir = envBasedirResult?.value;
+	const envBasedirKey = envBasedirResult?.key;
+	const envBasedirIsGeneric = envBasedirKey ? GENERIC_ENV_BASEDIR_KEYS.has(envBasedirKey) : false;
+	const packageEnvBasedir = pickPackageEnvBasedir();
+	const callerBasedir = !envBasedir || envBasedirIsGeneric ? detectCallerBasedir() : void 0;
+	const cwd = node_process.default.cwd();
+	const anchor = envBasedir ?? packageEnvBasedir ?? fallback ?? callerBasedir ?? cwd;
+	const resolveRelative = (value) => node_path.default.isAbsolute(value) ? node_path.default.normalize(value) : node_path.default.normalize(node_path.default.resolve(anchor, value));
+	if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("resolveTailwindcssBasedir anchor %O", {
+		basedir,
+		envBasedir,
+		envBasedirKey,
+		envBasedirIsGeneric,
+		packageEnvBasedir,
+		fallback,
+		callerBasedir,
+		npm_package_json: node_process.default.env["npm_package_json"],
+		cwd,
+		anchor
+	});
+	if (basedir && basedir.trim().length > 0) return resolveRelative(basedir);
+	if (envBasedir && !envBasedirIsGeneric) return node_path.default.normalize(envBasedir);
+	if (fallback && fallback.trim().length > 0) return resolveRelative(fallback);
+	if (packageEnvBasedir) return node_path.default.normalize(packageEnvBasedir);
+	if (callerBasedir) {
+		const normalizedCaller = node_path.default.normalize(callerBasedir);
+		const librarySegment = `${node_path.default.sep}weapp-tailwindcss${node_path.default.sep}`;
+		if (!normalizedCaller.includes(librarySegment)) return normalizedCaller;
+	}
+	const packageName = node_process.default.env["PNPM_PACKAGE_NAME"];
+	if (packageName) try {
+		const packageJsonPath = (0, node_module.createRequire)(node_path.default.join(anchor, "__resolve_tailwindcss_basedir__.cjs")).resolve(`${packageName}/package.json`);
+		if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("package basedir resolved from PNPM_PACKAGE_NAME: %s", packageJsonPath);
+		return node_path.default.normalize(node_path.default.dirname(packageJsonPath));
+	} catch {
+		if (node_process.default.env["WEAPP_TW_DEBUG_STACK"] === "1") _weapp_tailwindcss_logger.logger.debug("failed to resolve package json for %s", packageName);
+		const workspaceRoot = require_v4_engine.findWorkspaceRoot(anchor);
+		if (workspaceRoot) {
+			const packageDir = require_v4_engine.findWorkspacePackageDir(workspaceRoot, packageName);
+			if (packageDir) return packageDir;
+		}
+	}
+	if (envBasedir) return node_path.default.normalize(envBasedir);
+	return node_path.default.normalize(cwd);
+}
+//#endregion
+//#region src/context/tailwindcss.ts
+function createTailwindcssRuntimeFromContext(ctx) {
+	const { tailwindcssBasedir, supportCustomLengthUnits, tailwindcss, tailwindcssRuntimeOptions, cssEntries: rawCssEntries, appType, arbitraryValues } = ctx;
+	const effectiveSupportCustomLengthUnits = ctx.generator?.target === "web" ? false : supportCustomLengthUnits;
+	const absoluteCssEntryBasedir = require_v4_engine.guessBasedirFromEntries(rawCssEntries);
+	const resolvedTailwindcssBasedir = resolveTailwindcssBasedir(tailwindcssBasedir, absoluteCssEntryBasedir);
+	ctx.tailwindcssBasedir = resolvedTailwindcssBasedir;
+	_weapp_tailwindcss_logger.logger.debug("tailwindcss basedir resolved: %s", resolvedTailwindcssBasedir);
+	const normalizedCssEntries = require_v4_engine.normalizeCssEntries(rawCssEntries, resolvedTailwindcssBasedir);
+	if (normalizedCssEntries) ctx.cssEntries = normalizedCssEntries;
+	const runtimeOptions = {
+		tailwindcss,
+		tailwindcssRuntimeOptions,
+		supportCustomLengthUnits: effectiveSupportCustomLengthUnits,
+		appType,
+		bareArbitraryValues: arbitraryValues?.bareArbitraryValues
+	};
+	const workspaceRoot = require_v4_engine.findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? require_v4_engine.findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
+	const groupedCssEntries = normalizedCssEntries ? require_v4_engine.groupCssEntriesByBase(normalizedCssEntries, require_v4_engine.omitUndefined({
+		preferredBaseDir: resolvedTailwindcssBasedir,
+		workspaceRoot
+	})) : void 0;
+	const multiRuntime = groupedCssEntries ? tryCreateMultiTailwindcssRuntime(groupedCssEntries, runtimeOptions) : void 0;
+	if (multiRuntime) return multiRuntime;
+	if (groupedCssEntries?.size === 1) {
+		const firstGroup = groupedCssEntries.entries().next().value;
+		if (firstGroup) {
+			const [baseDir, entries] = firstGroup;
+			return createTailwindcssRuntimeForBase(baseDir, entries, runtimeOptions);
+		}
+	}
+	return createTailwindcssRuntimeForBase(resolvedTailwindcssBasedir, normalizedCssEntries ?? rawCssEntries, runtimeOptions);
+}
+//#endregion
+Object.defineProperty(exports, "applyV4CssCalcDefaults", {
+	enumerable: true,
+	get: function() {
+		return applyV4CssCalcDefaults;
+	}
+});
+Object.defineProperty(exports, "createTailwindcssRuntimeFromContext", {
+	enumerable: true,
+	get: function() {
+		return createTailwindcssRuntimeFromContext;
+	}
+});
+Object.defineProperty(exports, "createViteSourceScanMatcher", {
+	enumerable: true,
+	get: function() {
+		return createViteSourceScanMatcher;
+	}
+});
+Object.defineProperty(exports, "discoverTailwindV4CssEntries", {
+	enumerable: true,
+	get: function() {
+		return discoverTailwindV4CssEntries;
+	}
+});
+Object.defineProperty(exports, "findTailwindConfig", {
+	enumerable: true,
+	get: function() {
+		return findTailwindConfig;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetCacheEntry", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetCacheEntry;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetSignature", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetSignature;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetSignatureWithSources", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetSignatureWithSources;
+	}
+});
+Object.defineProperty(exports, "invalidateRuntimeClassSet", {
+	enumerable: true,
+	get: function() {
+		return invalidateRuntimeClassSet;
+	}
+});
+Object.defineProperty(exports, "isUniAppXEnabled", {
+	enumerable: true,
+	get: function() {
+		return isUniAppXEnabled;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4EntriesFromCss", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4EntriesFromCss;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4EntriesFromCssCached", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4EntriesFromCssCached;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindcssBasedir", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindcssBasedir;
+	}
+});
+Object.defineProperty(exports, "resolveUniAppXOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveUniAppXOptions;
+	}
+});
+Object.defineProperty(exports, "resolveViteSourceScanEntries", {
+	enumerable: true,
+	get: function() {
+		return resolveViteSourceScanEntries;
+	}
+});
+Object.defineProperty(exports, "resolveViteTailwindV4CssDependencies", {
+	enumerable: true,
+	get: function() {
+		return resolveViteTailwindV4CssDependencies;
+	}
+});
+Object.defineProperty(exports, "warnMissingCssEntries", {
+	enumerable: true,
+	get: function() {
+		return warnMissingCssEntries;
+	}
+});