weapp-tailwindcss 5.0.12 → 5.1.0

package/dist/tailwindcss-wyUHrfil.mjs

@@ -0,0 +1,1418 @@
+import { Q as expandTailwindSourceEntries, X as FULL_SOURCE_SCAN_PATTERN, Z as createTailwindSourceEntryMatcher, _ as resolveTailwindcssOptions, a as filterTailwindV4CssSourceRoots, c as groupCssEntriesByBase, ct as omitUndefined, d as normalizeCssEntries, et as normalizeLegacyContentEntries, f as findNearestPackageRoot, g as normalizeTailwindcssRuntimeOptions, h as normalizeExtendLengthUnits, i as resolveTailwindV4SourceOptionsFromRuntime, it as resolveTailwindV4CssSourceBase, l as guessBasedirFromEntries, m as findWorkspaceRoot, n as resolveTailwindV4SourceFromRuntime, nt as resolveCssSourceEntries, o as hasConfiguredTailwindV4CssRoots, ot as collectCssInlineSourceCandidates, p as findWorkspacePackageDir, tt as parseConfigParam, u as isTailwindV4CssEntry, v as normalizeStringListOption } from "./v4-engine-CF9zt4Cw.mjs";
+import { n as defuOverrideArray$1 } from "./utils-DodxWHGz.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { extractProjectCandidatesWithPositions } from "@tailwindcss-mangle/engine";
+import { postcss } from "@weapp-tailwindcss/postcss";
+import { stat } from "node:fs/promises";
+import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+import { logger } from "@weapp-tailwindcss/logger";
+import fg from "fast-glob";
+import { loadConfig } from "tailwindcss-config";
+import { fileURLToPath } from "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 = 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 = 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 path.isAbsolute(sourcePath) ? sourcePath : path.resolve(base, sourcePath);
+}
+function resolveConfigPath(base, configPath) {
+	if (path.isAbsolute(configPath)) return path.resolve(configPath);
+	return path.resolve(base, configPath);
+}
+function createCssEntriesCacheKey(css, base, dependencies) {
+	return JSON.stringify({
+		base: path.resolve(base),
+		css,
+		dependencies
+	});
+}
+async function statConfigDependency(file) {
+	try {
+		const stats = await 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 = 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 = 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(...normalizeLegacyContentEntries(staticContent, path.dirname(configPath), { relativeBase: path.dirname(configPath) }));
+			continue;
+		}
+		try {
+			const loaded = await loadConfig({
+				config: configPath,
+				cwd: path.dirname(configPath)
+			});
+			entries.push(...normalizeLegacyContentEntries(loaded?.config.content, path.dirname(configPath), { relativeBase: path.dirname(configPath) }));
+		} catch {}
+	}
+	return {
+		dependencies: [...configPaths],
+		entries
+	};
+}
+async function resolveTailwindV4EntriesFromCss(css, base) {
+	let root;
+	try {
+		root = postcss.parse(css);
+	} catch {
+		return;
+	}
+	let importSourceBase;
+	let hasSourceNone = false;
+	let hasTailwindCssImport = false;
+	const [sourceEntries, configEntries] = await Promise.all([resolveCssSourceEntries(root, base, VITE_SOURCE_CANDIDATE_PATTERN), resolveConfigContentEntries(root, base)]);
+	const entries = [...configEntries.entries, ...sourceEntries];
+	const hasPositiveEntries = entries.some((entry) => !entry.negated);
+	const inlineCandidates = 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(isTailwindV4CssEntry).map((item) => path.resolve(item)).filter((item) => existsSync(item));
+}
+async function pathExistsAsFile(file) {
+	try {
+		return (await stat(file)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindV4EntriesFromCssCached(css, base) {
+	let root;
+	try {
+		root = 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 = path.resolve(root);
+	const ignore = ["**/node_modules/**", "**/.git/**"];
+	const resolvedOutDir = outDir ? path.resolve(resolvedRoot, outDir) : void 0;
+	if (resolvedOutDir) {
+		const relativeOutDir = path.relative(resolvedRoot, resolvedOutDir);
+		if (relativeOutDir && !relativeOutDir.startsWith("..") && !path.isAbsolute(relativeOutDir)) ignore.push(`${relativeOutDir.split(path.sep).join("/")}/**`);
+	}
+	const candidates = await fg(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 = readFileSync(file, "utf8");
+			if (css.includes("tailwindcss") || css.includes("@source") || css.includes("@config")) {
+				if (await resolveTailwindV4EntriesFromCssCached(css, path.dirname(file))) entries.push(file);
+			}
+		} catch {}
+	}
+	return entries;
+}
+function collectConfiguredCssSources(options) {
+	return 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(path.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 = 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 && path.resolve(scanRoot) === path.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 = readFileSync(cssEntry, "utf8");
+		} catch {
+			continue;
+		}
+		readableCssEntryCount++;
+		const resolved = await resolveTailwindV4EntriesFromCssCached(css, path.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 ?? process.cwd());
+		return resolved ? createResolvedViteSourceScan(createResolvedV4CssScanInput(resolved.entries, resolved.inlineCandidates, resolved.explicit), new Set(resolved.dependencies)) : void 0;
+	}
+	const sourceOptionBase = sourceOptions.base ?? sourceOptions.projectRoot ?? process.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, 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 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 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 = statSync(filePath);
+		signature = `${filePath}:${stats.size}:${stats.mtimeMs}`;
+	} catch {
+		signature = `${filePath}:missing`;
+	}
+	runtimeFileSignatureCache.set(filePath, signature);
+	scheduleRuntimeConfigSignatureCacheClear();
+	return signature;
+}
+function getTailwindTrackedFiles(tailwindRuntime) {
+	const tailwindOptions = 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 (!existsSync(entry)) return `${entry}:missing`;
+			return getFileSignature(entry);
+		}),
+		cssSources
+	});
+}
+async function collectTailwindV4TrackedSourceFiles(tailwindRuntime) {
+	const tailwindOptions = 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 (!existsSync(cssEntry)) continue;
+		const resolved = await resolveTailwindV4EntriesFromCssCached(readFileSync(cssEntry, "utf8"), path.dirname(cssEntry));
+		const expanded = resolved?.entries?.length ? await 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 ? path.dirname(cssSource.file) : tailwindOptions?.v4?.base ?? tailwindOptions?.cwd ?? tailwindRuntime.options?.projectRoot ?? process.cwd();
+		const resolved = await resolveTailwindV4EntriesFromCssCached(cssSource.css, base);
+		const expanded = resolved?.entries?.length ? await 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 = 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 = normalizeStringListOption(entries)?.filter(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) || hasConfiguredTailwindV4CssRoots(ctx)) return;
+	hasWarnedMissingCssEntries = true;
+	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 (path.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 createRequire(import.meta.url).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 = path.join(dir, "node_modules");
+	if (existsSync(nodeModulesDir)) paths.add(nodeModulesDir);
+}
+function findTailwindConfig(searchRoots) {
+	for (const root of searchRoots) for (const file of TAILWIND_CONFIG_FILES) {
+		const candidate = path.resolve(root, file);
+		if (existsSync(candidate)) return candidate;
+	}
+}
+function createDefaultResolvePaths(basedir) {
+	const paths = /* @__PURE__ */ new Set();
+	let fallbackCandidates = [];
+	if (basedir) {
+		const resolvedBase = path.resolve(basedir);
+		appendNodeModules(paths, resolvedBase);
+		fallbackCandidates.push(resolvedBase);
+		const packageRoot = findNearestPackageRoot(resolvedBase);
+		if (packageRoot) {
+			appendNodeModules(paths, packageRoot);
+			fallbackCandidates.push(packageRoot);
+		}
+		const workspaceRoot = findWorkspaceRoot(resolvedBase);
+		if (workspaceRoot) {
+			appendNodeModules(paths, workspaceRoot);
+			fallbackCandidates.push(workspaceRoot);
+		}
+	}
+	const cwd = process.cwd();
+	appendNodeModules(paths, cwd);
+	try {
+		const modulePath = fileURLToPath(import.meta.url);
+		const candidate = existsSync(modulePath) && !path.extname(modulePath) ? modulePath : path.dirname(modulePath);
+		paths.add(candidate);
+	} catch {
+		paths.add(import.meta.url);
+	}
+	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(readFileSync(packageJsonPath, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findPackageJsonDeclaringPackage(packageName, base) {
+	let current = path.resolve(base);
+	while (true) {
+		const pkgPath = path.join(current, "package.json");
+		if (existsSync(pkgPath)) {
+			const pkg = readPackageJson(pkgPath);
+			if (readDeclaredPackageVersion(packageName, pkg)) return pkgPath;
+			if (pkg?.name !== "weapp-tailwindcss") return;
+		}
+		const parent = path.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 = 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 = createRequire(import.meta.url);
+function createPackageInfo(tailwindOptions) {
+	const packageName = tailwindOptions?.packageName ?? "tailwindcss";
+	const resolvePaths = tailwindOptions?.resolve?.paths;
+	let rootPath;
+	const cwdPackageJsonPath = tailwindOptions?.cwd ? path.join(tailwindOptions.cwd, "package.json") : void 0;
+	if (cwdPackageJsonPath) try {
+		if (require(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 = createRequire(path.join(resolvePath, "package.json")).resolve(`${packageName}/package.json`);
+			break;
+		} catch {}
+	}
+	if (rootPath) {
+		const packageJsonPath = rootPath;
+		const packageRoot = path.dirname(packageJsonPath);
+		try {
+			const packageJson = require(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 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 {
+				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 resolveTailwindV4SourceFromRuntime(runtime);
+		const report = await 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 ? path.resolve(basedir) : void 0;
+	const cacheRoot = findNearestPackageRoot(normalizedBasedir) ?? normalizedBasedir ?? process.cwd();
+	if (cacheDir) if (path.isAbsolute(cacheDir)) cache.dir = cacheDir;
+	else if (normalizedBasedir) cache.dir = path.resolve(normalizedBasedir, cacheDir);
+	else cache.dir = path.resolve(process.cwd(), cacheDir);
+	else cache.dir = path.join(cacheRoot, "node_modules", ".cache", "@tailwindcss-mangle", "engine");
+	if (normalizedBasedir) cache.cwd = normalizedBasedir;
+	const resolvePaths = createDefaultResolvePaths(cache.cwd ?? normalizedBasedir ?? process.cwd());
+	const normalizedUserOptions = normalizeTailwindcssRuntimeOptions(tailwindcssRuntimeOptions);
+	const extendLengthUnits = normalizeExtendLengthUnits(supportCustomLengthUnits ?? true);
+	const baseTailwindOptions = defuOverrideArray(tailwindcss ?? {}, 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 = omitUndefined({
+		projectRoot: normalizedBasedir,
+		cache,
+		tailwindcss: baseTailwindOptions,
+		apply: omitUndefined({
+			exposeContext: true,
+			extendLengthUnits
+		})
+	});
+	const resolvedOptions = 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)]
+		};
+		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 = path.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 = path.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) {
+				logger.warn("Tailwind CSS 未安装，已跳过 Tailwind 运行时能力。若需使用 Tailwind 能力，请安装 tailwindcss。");
+				hasLoggedMissingTailwind = true;
+			}
+			return createFallbackTailwindcssRuntime(resolvedOptions);
+		}
+		if (error instanceof Error && UNABLE_TO_LOCATE_TAILWINDCSS_RE.test(error.message)) 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 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 (!existsSync(path.join(baseDir, "index.css"))) return;
+		const name = JSON.parse(readFileSync(path.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 ? omitUndefined({ cssEntries }) : omitUndefined({
+			base: baseDir,
+			cssEntries
+		})
+	};
+	const mergedTailwindOptions = defuOverrideArray$1(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(omitUndefined({
+		basedir: baseDir,
+		supportCustomLengthUnits: supportCustomLengthUnits ?? true,
+		tailwindcss: tailwindOptionsForPackage,
+		tailwindcssRuntimeOptions: patchedOptions
+	}));
+}
+function tryCreateMultiTailwindcssRuntime(groups, options) {
+	if (groups.size <= 1) return;
+	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 = process.env[key];
+		if (value && path.isAbsolute(value)) return {
+			key,
+			value
+		};
+	}
+}
+function pickPackageEnvBasedir() {
+	const packageJsonPath = process.env["npm_package_json"];
+	if (packageJsonPath) {
+		const packageDir = path.dirname(packageJsonPath);
+		if (packageDir && path.isAbsolute(packageDir)) return packageDir;
+	}
+	const localPrefix = process.env["npm_config_local_prefix"];
+	if (localPrefix && path.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 (process.env["WEAPP_TW_DEBUG_STACK"] === "1") 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 = fileURLToPath(filePath);
+		} catch {
+			continue;
+		}
+		const [candidate = ""] = filePath.split(":");
+		const resolvedPath = path.isAbsolute(filePath) ? filePath : candidate;
+		if (!path.isAbsolute(resolvedPath)) continue;
+		if (resolvedPath.includes("node_modules") && resolvedPath.includes("weapp-tailwindcss")) continue;
+		try {
+			return path.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 = process.cwd();
+	const anchor = envBasedir ?? packageEnvBasedir ?? fallback ?? callerBasedir ?? cwd;
+	const resolveRelative = (value) => path.isAbsolute(value) ? path.normalize(value) : path.normalize(path.resolve(anchor, value));
+	if (process.env["WEAPP_TW_DEBUG_STACK"] === "1") logger.debug("resolveTailwindcssBasedir anchor %O", {
+		basedir,
+		envBasedir,
+		envBasedirKey,
+		envBasedirIsGeneric,
+		packageEnvBasedir,
+		fallback,
+		callerBasedir,
+		npm_package_json: process.env["npm_package_json"],
+		cwd,
+		anchor
+	});
+	if (basedir && basedir.trim().length > 0) return resolveRelative(basedir);
+	if (envBasedir && !envBasedirIsGeneric) return path.normalize(envBasedir);
+	if (fallback && fallback.trim().length > 0) return resolveRelative(fallback);
+	if (packageEnvBasedir) return path.normalize(packageEnvBasedir);
+	if (callerBasedir) {
+		const normalizedCaller = path.normalize(callerBasedir);
+		const librarySegment = `${path.sep}weapp-tailwindcss${path.sep}`;
+		if (!normalizedCaller.includes(librarySegment)) return normalizedCaller;
+	}
+	const packageName = process.env["PNPM_PACKAGE_NAME"];
+	if (packageName) try {
+		const packageJsonPath = createRequire(path.join(anchor, "__resolve_tailwindcss_basedir__.cjs")).resolve(`${packageName}/package.json`);
+		if (process.env["WEAPP_TW_DEBUG_STACK"] === "1") logger.debug("package basedir resolved from PNPM_PACKAGE_NAME: %s", packageJsonPath);
+		return path.normalize(path.dirname(packageJsonPath));
+	} catch {
+		if (process.env["WEAPP_TW_DEBUG_STACK"] === "1") logger.debug("failed to resolve package json for %s", packageName);
+		const workspaceRoot = findWorkspaceRoot(anchor);
+		if (workspaceRoot) {
+			const packageDir = findWorkspacePackageDir(workspaceRoot, packageName);
+			if (packageDir) return packageDir;
+		}
+	}
+	if (envBasedir) return path.normalize(envBasedir);
+	return path.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 = guessBasedirFromEntries(rawCssEntries);
+	const resolvedTailwindcssBasedir = resolveTailwindcssBasedir(tailwindcssBasedir, absoluteCssEntryBasedir);
+	ctx.tailwindcssBasedir = resolvedTailwindcssBasedir;
+	logger.debug("tailwindcss basedir resolved: %s", resolvedTailwindcssBasedir);
+	const normalizedCssEntries = normalizeCssEntries(rawCssEntries, resolvedTailwindcssBasedir);
+	if (normalizedCssEntries) ctx.cssEntries = normalizedCssEntries;
+	const runtimeOptions = {
+		tailwindcss,
+		tailwindcssRuntimeOptions,
+		supportCustomLengthUnits: effectiveSupportCustomLengthUnits,
+		appType,
+		bareArbitraryValues: arbitraryValues?.bareArbitraryValues
+	};
+	const workspaceRoot = findWorkspaceRoot(resolvedTailwindcssBasedir) ?? (absoluteCssEntryBasedir ? findWorkspaceRoot(absoluteCssEntryBasedir) : void 0);
+	const groupedCssEntries = normalizedCssEntries ? groupCssEntriesByBase(normalizedCssEntries, 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
+export { resolveViteTailwindV4CssDependencies as _, findTailwindConfig as a, getRuntimeClassSetCacheEntry as c, invalidateRuntimeClassSet as d, createViteSourceScanMatcher as f, resolveTailwindV4EntriesFromCssCached as g, resolveTailwindV4EntriesFromCss as h, resolveUniAppXOptions as i, getRuntimeClassSetSignature as l, discoverTailwindV4CssEntries as m, resolveTailwindcssBasedir as n, applyV4CssCalcDefaults as o, resolveViteSourceScanEntries as p, isUniAppXEnabled as r, warnMissingCssEntries as s, createTailwindcssRuntimeFromContext as t, getRuntimeClassSetSignatureWithSources as u };