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

package/dist/v3-engine-D61eilBl.mjs

@@ -0,0 +1,3208 @@
+import { createRequire } from "node:module";
+import fs, { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import postcss from "postcss";
+import path from "node:path";
+import process from "node:process";
+import { logger } from "@weapp-tailwindcss/logger";
+import { defuOverrideArray } from "@weapp-tailwindcss/shared";
+import { TailwindcssPatcher, createTailwindV4Engine, loadTailwindV4DesignSystem, resolveTailwindV4Source, resolveTailwindV4SourceFromPatchOptions } from "tailwindcss-patch";
+import { fileURLToPath } from "node:url";
+import _createDebug from "debug";
+import { stat } from "node:fs/promises";
+import fg from "fast-glob";
+import micromatch from "micromatch";
+import { loadConfig } from "tailwindcss-config";
+import { createStyleHandler, protectDynamicColorMixAlpha } from "@weapp-tailwindcss/postcss";
+//#region src/context/workspace.ts
+const IGNORED_WORKSPACE_DIRS = new Set([
+	"node_modules",
+	".git",
+	".hg",
+	".svn",
+	".turbo",
+	".output",
+	".next",
+	"dist",
+	"build"
+]);
+function findWorkspaceRoot(startDir) {
+	if (!startDir) return;
+	let current = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findNearestPackageRoot(startDir) {
+	if (!startDir) return;
+	let current = path.resolve(startDir);
+	while (true) {
+		if (existsSync(path.join(current, "package.json"))) return current;
+		const parent = path.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findWorkspacePackageDir(rootDir, packageName) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [path.resolve(rootDir)];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const normalized = path.normalize(current);
+		if (visited.has(normalized)) continue;
+		visited.add(normalized);
+		try {
+			const pkgPath = path.join(normalized, "package.json");
+			if (existsSync(pkgPath)) {
+				if (JSON.parse(readFileSync(pkgPath, "utf8"))?.name === packageName) return normalized;
+			}
+		} catch {}
+		let entries;
+		try {
+			entries = readdirSync(normalized, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (!entry.isDirectory() || IGNORED_WORKSPACE_DIRS.has(entry.name) || entry.isSymbolicLink?.()) continue;
+			queue.push(path.join(normalized, entry.name));
+		}
+	}
+}
+//#endregion
+//#region src/utils/object.ts
+function definedEntries(value) {
+	return Object.entries(value).filter(([, item]) => item !== void 0);
+}
+function omitUndefined(value) {
+	return Object.fromEntries(definedEntries(value));
+}
+//#endregion
+//#region src/tailwindcss/patcher-options.ts
+function resolveTailwindcssOptions(options) {
+	return options?.tailwindcss ?? options?.tailwind;
+}
+function normalizeExtendLengthUnits(value) {
+	if (value === false) return false;
+	if (value === true) return { enabled: true };
+	if (value && typeof value === "object") return {
+		enabled: true,
+		...value
+	};
+}
+function normalizeTailwindcssPatcherOptions(options) {
+	return options;
+}
+//#endregion
+//#region src/tailwindcss/patcher-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 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 === 3 || 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)([34])(?:\.|\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/patcher.ts
+function createFallbackTailwindcssPatcher() {
+	return {
+		packageInfo: {
+			name: "tailwindcss",
+			version: void 0,
+			rootPath: "",
+			packageJsonPath: "",
+			packageJson: {}
+		},
+		majorVersion: 4,
+		async getClassSet() {
+			return /* @__PURE__ */ new Set();
+		},
+		async extract(_options) {
+			return {
+				classList: [],
+				classSet: /* @__PURE__ */ new Set()
+			};
+		},
+		async collectContentTokens() {
+			return {
+				entries: [],
+				filesScanned: 0,
+				sources: [],
+				skippedFiles: []
+			};
+		}
+	};
+}
+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 isTailwindcssV4PackageName(packageName) {
+	return packageName === "@tailwindcss/postcss" || packageName === "tailwindcss4" || Boolean(packageName && packageName.includes("tailwindcss4"));
+}
+function createTailwindcssPatcher(options) {
+	const { basedir, cacheDir, supportCustomLengthUnitsPatch, tailwindcss, tailwindcssPatcherOptions } = options || {};
+	const cache = { 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-patch");
+	if (normalizedBasedir) cache.cwd = normalizedBasedir;
+	const resolvePaths = createDefaultResolvePaths(cache.cwd ?? normalizedBasedir ?? process.cwd());
+	const normalizedUserOptions = normalizeTailwindcssPatcherOptions(tailwindcssPatcherOptions);
+	const extendLengthUnits = normalizeExtendLengthUnits(supportCustomLengthUnitsPatch ?? true);
+	const baseTailwindOptions = defuOverrideArray(tailwindcss ?? {}, omitUndefined({
+		cwd: normalizedBasedir,
+		resolve: { paths: resolvePaths }
+	}));
+	if (!baseTailwindOptions.packageName) baseTailwindOptions.packageName = "tailwindcss";
+	if (!baseTailwindOptions.postcssPlugin) baseTailwindOptions.postcssPlugin = baseTailwindOptions.version === 4 || isTailwindcssV4PackageName(baseTailwindOptions.packageName) ? "@tailwindcss/postcss" : "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;
+		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 new TailwindcssPatcher(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 createFallbackTailwindcssPatcher();
+		}
+		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/debug/index.ts
+const _debug = _createDebug("weapp-tw");
+function createDebug(prefix) {
+	const debug = ((formatter, ...args) => {
+		return _debug((prefix ?? "") + formatter, ...args);
+	});
+	Object.defineProperty(debug, "enabled", {
+		enumerable: false,
+		configurable: false,
+		get() {
+			return _debug.enabled;
+		}
+	});
+	return debug;
+}
+//#endregion
+//#region src/tailwindcss/source-scan.ts
+const DEFAULT_SOURCE_SCAN_EXTENSIONS = [
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"vue",
+	"mpx",
+	"js",
+	"jsx",
+	"ts",
+	"tsx"
+];
+function createSourceScanPattern(extensions = DEFAULT_SOURCE_SCAN_EXTENSIONS) {
+	return `**/*.{${extensions.join(",")}}`;
+}
+const NUMERICAL_RANGE_RE = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+function parseConfigParam$1(params) {
+	const value = params.trim();
+	return /^(['"])(.+)\1$/.exec(value)?.[2];
+}
+function isLegacyContentObject$1(value) {
+	return typeof value === "object" && value !== null && "files" in value;
+}
+function normalizeGlobPattern(pattern) {
+	return pattern.startsWith("./") ? pattern.slice(2) : pattern;
+}
+function hasGlobMagic(value) {
+	return /[*?[\]{}()!+@]/.test(value);
+}
+function splitStaticGlobPrefix(pattern) {
+	const segments = normalizeGlobPattern(pattern).split(/[\\/]+/);
+	const prefix = [];
+	const rest = [];
+	let reachedGlob = false;
+	for (const segment of segments) {
+		if (!reachedGlob && segment && !hasGlobMagic(segment)) {
+			prefix.push(segment);
+			continue;
+		}
+		reachedGlob = true;
+		rest.push(segment);
+	}
+	return {
+		prefix,
+		rest
+	};
+}
+function segmentTopLevel(input, separator) {
+	const parts = [];
+	const stack = [];
+	let lastPos = 0;
+	let quote;
+	for (let index = 0; index < input.length; index++) {
+		const char = input[index];
+		if (char === "\\") {
+			index += 1;
+			continue;
+		}
+		if (quote) {
+			if (char === quote) quote = void 0;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			continue;
+		}
+		if (char === "(") {
+			stack.push(")");
+			continue;
+		}
+		if (char === "[") {
+			stack.push("]");
+			continue;
+		}
+		if (char === "{") {
+			stack.push("}");
+			continue;
+		}
+		if (stack.length > 0 && char === stack[stack.length - 1]) {
+			stack.pop();
+			continue;
+		}
+		if (stack.length === 0 && char === separator) {
+			parts.push(input.slice(lastPos, index));
+			lastPos = index + 1;
+		}
+	}
+	parts.push(input.slice(lastPos));
+	return parts;
+}
+function isSequence(value) {
+	return NUMERICAL_RANGE_RE.test(value);
+}
+function expandSequence(value) {
+	const match = value.match(NUMERICAL_RANGE_RE);
+	if (!match) return [value];
+	const [, start, end, stepValue] = match;
+	if (start === void 0 || end === void 0) return [value];
+	let step = stepValue ? Number.parseInt(stepValue, 10) : void 0;
+	const startNumber = Number.parseInt(start, 10);
+	const endNumber = Number.parseInt(end, 10);
+	const increasing = startNumber < endNumber;
+	if (step === void 0) step = increasing ? 1 : -1;
+	if (step === 0) return [];
+	if (increasing && step < 0) step = -step;
+	if (!increasing && step > 0) step = -step;
+	const result = [];
+	for (let value = startNumber; increasing ? value <= endNumber : value >= endNumber; value += step) result.push(String(value));
+	return result;
+}
+function expandInlineSourceCandidatePattern(pattern) {
+	const index = pattern.indexOf("{");
+	if (index === -1) return [pattern];
+	const prefix = pattern.slice(0, index);
+	const rest = pattern.slice(index);
+	let depth = 0;
+	let endIndex = -1;
+	for (let index = 0; index < rest.length; index++) {
+		const char = rest[index];
+		if (char === "{") depth += 1;
+		else if (char === "}") {
+			depth -= 1;
+			if (depth === 0) {
+				endIndex = index;
+				break;
+			}
+		}
+	}
+	if (endIndex === -1) return [pattern];
+	const inner = rest.slice(1, endIndex);
+	const suffix = rest.slice(endIndex + 1);
+	const parts = (isSequence(inner) ? expandSequence(inner) : segmentTopLevel(inner, ",")).flatMap((part) => expandInlineSourceCandidatePattern(part));
+	return expandInlineSourceCandidatePattern(suffix).flatMap((suffix) => parts.map((part) => `${prefix}${part}${suffix}`));
+}
+function parseSourceInlineParam(params) {
+	let value = params.trim();
+	const negated = value.startsWith("not ");
+	if (negated) value = value.slice(4).trim();
+	if (!value.startsWith("inline(") || !value.endsWith(")")) return;
+	const inlineValue = value.slice(7, -1).trim();
+	const match = /^(['"])([\s\S]*)\1$/.exec(inlineValue);
+	if (!match) return;
+	const source = match[2];
+	if (source === void 0) return;
+	return {
+		negated,
+		source
+	};
+}
+function collectCssInlineSourceCandidates(root) {
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceInlineParam(rule.params);
+		if (!parsed) return;
+		const target = parsed.negated ? excluded : included;
+		for (const source of segmentTopLevel(parsed.source, " ")) {
+			const trimmed = source.trim();
+			if (!trimmed) continue;
+			for (const candidate of expandInlineSourceCandidatePattern(trimmed)) {
+				const normalized = candidate.trim();
+				if (normalized) target.add(normalized);
+			}
+		}
+	});
+	for (const candidate of excluded) included.delete(candidate);
+	return {
+		included,
+		excluded
+	};
+}
+function normalizeLegacyContentEntries(content, base) {
+	if (typeof content === "string") {
+		const negated = content.startsWith("!");
+		return [{
+			base,
+			negated,
+			pattern: normalizeGlobPattern(negated ? content.slice(1) : content)
+		}];
+	}
+	if (Array.isArray(content)) return content.flatMap((item) => normalizeLegacyContentEntries(item, base));
+	if (isLegacyContentObject$1(content)) return normalizeLegacyContentEntries(content.files, base);
+	return [];
+}
+async function pathExistsAsDirectory(file) {
+	try {
+		return (await stat(file)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindSourceEntry(sourcePath, base, negated, defaultPattern = createSourceScanPattern()) {
+	const absoluteSource = path.isAbsolute(sourcePath) ? path.resolve(sourcePath) : path.resolve(base, sourcePath);
+	if (await pathExistsAsDirectory(absoluteSource)) return {
+		base: absoluteSource,
+		negated,
+		pattern: normalizeGlobPattern(defaultPattern)
+	};
+	if (path.isAbsolute(sourcePath)) return {
+		base: path.dirname(absoluteSource),
+		negated,
+		pattern: normalizeGlobPattern(path.basename(absoluteSource))
+	};
+	const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+	if (prefix.length > 0 && rest.length > 0) return {
+		base: path.resolve(base, ...prefix),
+		negated,
+		pattern: normalizeGlobPattern(rest.join("/"))
+	};
+	return {
+		base,
+		negated,
+		pattern: normalizeGlobPattern(sourcePath)
+	};
+}
+function parseSourceFileParam$1(params) {
+	const value = params.trim();
+	if (!value || value === "none" || value.startsWith("inline(")) return;
+	const negated = value.startsWith("not ");
+	const sourceValue = negated ? value.slice(4).trim() : value;
+	if (sourceValue.startsWith("inline(")) return;
+	const match = /^(['"])(.+)\1$/.exec(sourceValue);
+	return match?.[2] ? {
+		negated,
+		sourcePath: match[2]
+	} : void 0;
+}
+async function resolveCssSourceEntries(root, base, defaultPattern = createSourceScanPattern()) {
+	const entries = [];
+	const tasks = [];
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceFileParam$1(rule.params);
+		if (!parsed) return;
+		tasks.push(resolveTailwindSourceEntry(parsed.sourcePath, base, parsed.negated, defaultPattern));
+	});
+	entries.push(...await Promise.all(tasks));
+	return entries;
+}
+async function expandTailwindSourceEntries(entries, options = {}) {
+	const files = /* @__PURE__ */ new Set();
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	const entriesByBase = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const base = path.resolve(entry.base);
+		const group = entriesByBase.get(base) ?? [];
+		group.push({
+			...entry,
+			base
+		});
+		entriesByBase.set(base, group);
+	}
+	await Promise.all([...entriesByBase.entries()].map(async ([base, group]) => {
+		const patterns = group.map((entry) => {
+			const pattern = normalizeGlobPattern(entry.pattern);
+			return entry.negated ? `!${pattern}` : pattern;
+		});
+		if (!patterns.some((pattern) => !pattern.startsWith("!"))) return;
+		const ignore = options.ignore;
+		const matched = await fg(patterns, {
+			absolute: true,
+			cwd: base,
+			...ignore === void 0 ? {} : { ignore },
+			onlyFiles: true,
+			unique: true
+		});
+		for (const file of matched) files.add(path.resolve(file));
+	}));
+	return [...files].filter((file) => !negativeEntries.some((entry) => {
+		const relative = path.relative(path.resolve(entry.base), file).split(path.sep).join("/");
+		return relative && !relative.startsWith("../") && !path.isAbsolute(relative) && micromatch.isMatch(relative, normalizeGlobPattern(entry.pattern));
+	}));
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/candidates.ts
+const UNSUPPORTED_MINI_PROGRAM_TAILWIND_V4_CANDIDATE_RE = /(?:^|:)(?:group|peer|in|not-in)-[^\s:]*\/|(?:^|:)(?:in|not-in)-\[/;
+function isUnsupportedMiniProgramTailwindV4Candidate(candidate) {
+	return UNSUPPORTED_MINI_PROGRAM_TAILWIND_V4_CANDIDATE_RE.test(candidate);
+}
+function filterUnsupportedMiniProgramTailwindV4Candidates(candidates) {
+	if (!candidates) return;
+	return new Set([...candidates].filter((candidate) => !isUnsupportedMiniProgramTailwindV4Candidate(candidate)));
+}
+//#endregion
+//#region src/tailwindcss/remove-unsupported-css.ts
+/**
+* 移除小程序不支持的 cascade layer 语法，同时保留 layer 内的实际规则。
+*/
+function removeUnsupportedCascadeLayers(root) {
+	root.walkAtRules("layer", (atRule) => {
+		if (!atRule.nodes || atRule.nodes.length === 0) {
+			atRule.remove();
+			return;
+		}
+		atRule.replaceWith(...atRule.nodes);
+	});
+}
+//#endregion
+//#region src/tailwindcss/miniprogram.ts
+const DEFAULT_WEAPP_VARIABLE_SCOPE = "page,.tw-root,wx-root-portal-content,:host";
+const CLASS_SELECTOR_RE = /(?:^|[^\w-])\.[_a-z\u00A0-\uFFFF\\-]/i;
+const PSEUDO_CONTENT_SELECTOR_RE = /^(?:::before|::after|:before|:after)(?:,(?:::before|::after|:before|:after))*$/;
+const MINI_PROGRAM_PREFLIGHT_SELECTORS = new Set([
+	"*",
+	"view",
+	"text",
+	":before",
+	":after",
+	"::before",
+	"::after"
+]);
+const PREFLIGHT_RESET_PROPS = new Set([
+	"box-sizing",
+	"border",
+	"border-width",
+	"border-style",
+	"border-color",
+	"margin",
+	"padding"
+]);
+const CONTENT_VAR_RE = /var\(\s*--tw-content\b/;
+function hasClassSelector(selector) {
+	return CLASS_SELECTOR_RE.test(selector);
+}
+function normalizeSelector$1(selector) {
+	return selector.trim().replace(/\s+/g, "");
+}
+function getRuleSelectors(rule) {
+	return rule.selector.split(",").map(normalizeSelector$1).filter(Boolean);
+}
+function isCustomPropertyRule(rule) {
+	let hasDeclaration = false;
+	let allCustomProperties = true;
+	rule.walkDecls((decl) => {
+		hasDeclaration = true;
+		if (!decl.prop.startsWith("--")) allCustomProperties = false;
+	});
+	return hasDeclaration && allCustomProperties;
+}
+function isEmptyContentInitDeclaration(decl) {
+	return decl.prop === "--tw-content" && (decl.value === "\"\"" || decl.value === "''");
+}
+function removeEmptyContentInitDeclarations(rule) {
+	rule.walkDecls((decl) => {
+		if (isEmptyContentInitDeclaration(decl)) decl.remove();
+	});
+}
+function usesTwContentVariable(root) {
+	let used = false;
+	root.walkDecls((decl) => {
+		if (CONTENT_VAR_RE.test(decl.value)) used = true;
+	});
+	return used;
+}
+function isPseudoContentInitRule(rule) {
+	const selector = rule.selector.replace(/\s+/g, "");
+	if (!PSEUDO_CONTENT_SELECTOR_RE.test(selector)) return false;
+	let hasDeclaration = false;
+	let onlyContentVariable = true;
+	rule.walkDecls((decl) => {
+		hasDeclaration = true;
+		if (decl.prop !== "--tw-content") onlyContentVariable = false;
+	});
+	return hasDeclaration && onlyContentVariable;
+}
+function isMiniProgramPreflightRule(rule) {
+	const selectors = getRuleSelectors(rule);
+	if (selectors.length === 0 || !selectors.every((selector) => MINI_PROGRAM_PREFLIGHT_SELECTORS.has(selector)) || !selectors.some((selector) => selector === "*" || selector === ":before" || selector === ":after" || selector === "::before" || selector === "::after")) return false;
+	let hasTailwindVariable = false;
+	let hasResetProp = false;
+	rule.walkDecls((decl) => {
+		if (decl.prop.startsWith("--tw-")) hasTailwindVariable = true;
+		if (PREFLIGHT_RESET_PROPS.has(decl.prop)) hasResetProp = true;
+	});
+	return hasTailwindVariable || hasResetProp;
+}
+function isKeyframesRule(rule) {
+	let parent = rule.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name.endsWith("keyframes")) return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+/**
+* 裁剪 Tailwind 生成 CSS 中面向浏览器的 classless 规则。
+*
+* 生成模式面向小程序时只需要保留业务 utility 与 Tailwind 变量初始化；
+* 浏览器元素 reset、表单伪元素等 classless 规则不适合直接输出到小程序。
+*/
+function pruneMiniProgramGeneratedCss(css, options = {}) {
+	const root = postcss.parse(css);
+	const shouldPreserveContentInit = options.preservePreflight || usesTwContentVariable(root);
+	root.walkComments((comment) => {
+		comment.remove();
+	});
+	removeUnsupportedCascadeLayers(root);
+	root.walkAtRules("supports", (atRule) => {
+		atRule.remove();
+	});
+	root.walkRules((rule) => {
+		if (isKeyframesRule(rule)) return;
+		if (hasClassSelector(rule.selector)) return;
+		if (!shouldPreserveContentInit) removeEmptyContentInitDeclarations(rule);
+		if (isPseudoContentInitRule(rule)) {
+			if (!shouldPreserveContentInit) rule.remove();
+			return;
+		}
+		if (options.preservePreflight && isMiniProgramPreflightRule(rule)) return;
+		if (isCustomPropertyRule(rule)) {
+			rule.selector = DEFAULT_WEAPP_VARIABLE_SCOPE;
+			return;
+		}
+		rule.remove();
+	});
+	root.walkAtRules((atRule) => {
+		if (!atRule.nodes || atRule.nodes.length === 0) atRule.remove();
+	});
+	return root.toString();
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/miniprogram.ts
+const defaultStyleHandler$1 = createStyleHandler({
+	cssChildCombinatorReplaceValue: ["view", "text"],
+	cssRemoveHoverPseudoClass: true,
+	isMainChunk: true,
+	majorVersion: 4
+});
+const CSS_DECLARATION_URL_RE = /(:\s*)url\(([^\n\r"';[\]{}]*[[\]{}][^\n\r;]*)\)(?=\s*;)/g;
+function normalizeTailwindV4GeneratedUrlValues(css) {
+	return css.replace(CSS_DECLARATION_URL_RE, (match, prefix, urlValue) => {
+		try {
+			return `${prefix}url("${urlValue.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}")`;
+		} catch {
+			return match;
+		}
+	});
+}
+async function transformTailwindV4CssToWeapp(css, options) {
+	const protectedCss = protectDynamicColorMixAlpha(normalizeTailwindV4GeneratedUrlValues(css));
+	const result = await defaultStyleHandler$1(protectedCss.css, {
+		cssChildCombinatorReplaceValue: ["view", "text"],
+		cssRemoveHoverPseudoClass: true,
+		isMainChunk: true,
+		majorVersion: 4,
+		...options
+	});
+	return pruneMiniProgramGeneratedCss(protectedCss.restore(result.css));
+}
+async function transformTailwindV4CssByTarget(css, target, options) {
+	return target === "weapp" ? transformTailwindV4CssToWeapp(css, options) : css;
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/tailwind-v3-default-colors.ts
+const TAILWIND_V3_COLOR_STEPS = [
+	"50",
+	"100",
+	"200",
+	"300",
+	"400",
+	"500",
+	"600",
+	"700",
+	"800",
+	"900",
+	"950"
+];
+const TAILWIND_V3_COLOR_PALETTE = {
+	slate: [
+		"#f8fafc",
+		"#f1f5f9",
+		"#e2e8f0",
+		"#cbd5e1",
+		"#94a3b8",
+		"#64748b",
+		"#475569",
+		"#334155",
+		"#1e293b",
+		"#0f172a",
+		"#020617"
+	],
+	gray: [
+		"#f9fafb",
+		"#f3f4f6",
+		"#e5e7eb",
+		"#d1d5db",
+		"#9ca3af",
+		"#6b7280",
+		"#4b5563",
+		"#374151",
+		"#1f2937",
+		"#111827",
+		"#030712"
+	],
+	zinc: [
+		"#fafafa",
+		"#f4f4f5",
+		"#e4e4e7",
+		"#d4d4d8",
+		"#a1a1aa",
+		"#71717a",
+		"#52525b",
+		"#3f3f46",
+		"#27272a",
+		"#18181b",
+		"#09090b"
+	],
+	neutral: [
+		"#fafafa",
+		"#f5f5f5",
+		"#e5e5e5",
+		"#d4d4d4",
+		"#a3a3a3",
+		"#737373",
+		"#525252",
+		"#404040",
+		"#262626",
+		"#171717",
+		"#0a0a0a"
+	],
+	stone: [
+		"#fafaf9",
+		"#f5f5f4",
+		"#e7e5e4",
+		"#d6d3d1",
+		"#a8a29e",
+		"#78716c",
+		"#57534e",
+		"#44403c",
+		"#292524",
+		"#1c1917",
+		"#0c0a09"
+	],
+	red: [
+		"#fef2f2",
+		"#fee2e2",
+		"#fecaca",
+		"#fca5a5",
+		"#f87171",
+		"#ef4444",
+		"#dc2626",
+		"#b91c1c",
+		"#991b1b",
+		"#7f1d1d",
+		"#450a0a"
+	],
+	orange: [
+		"#fff7ed",
+		"#ffedd5",
+		"#fed7aa",
+		"#fdba74",
+		"#fb923c",
+		"#f97316",
+		"#ea580c",
+		"#c2410c",
+		"#9a3412",
+		"#7c2d12",
+		"#431407"
+	],
+	amber: [
+		"#fffbeb",
+		"#fef3c7",
+		"#fde68a",
+		"#fcd34d",
+		"#fbbf24",
+		"#f59e0b",
+		"#d97706",
+		"#b45309",
+		"#92400e",
+		"#78350f",
+		"#451a03"
+	],
+	yellow: [
+		"#fefce8",
+		"#fef9c3",
+		"#fef08a",
+		"#fde047",
+		"#facc15",
+		"#eab308",
+		"#ca8a04",
+		"#a16207",
+		"#854d0e",
+		"#713f12",
+		"#422006"
+	],
+	lime: [
+		"#f7fee7",
+		"#ecfccb",
+		"#d9f99d",
+		"#bef264",
+		"#a3e635",
+		"#84cc16",
+		"#65a30d",
+		"#4d7c0f",
+		"#3f6212",
+		"#365314",
+		"#1a2e05"
+	],
+	green: [
+		"#f0fdf4",
+		"#dcfce7",
+		"#bbf7d0",
+		"#86efac",
+		"#4ade80",
+		"#22c55e",
+		"#16a34a",
+		"#15803d",
+		"#166534",
+		"#14532d",
+		"#052e16"
+	],
+	emerald: [
+		"#ecfdf5",
+		"#d1fae5",
+		"#a7f3d0",
+		"#6ee7b7",
+		"#34d399",
+		"#10b981",
+		"#059669",
+		"#047857",
+		"#065f46",
+		"#064e3b",
+		"#022c22"
+	],
+	teal: [
+		"#f0fdfa",
+		"#ccfbf1",
+		"#99f6e4",
+		"#5eead4",
+		"#2dd4bf",
+		"#14b8a6",
+		"#0d9488",
+		"#0f766e",
+		"#115e59",
+		"#134e4a",
+		"#042f2e"
+	],
+	cyan: [
+		"#ecfeff",
+		"#cffafe",
+		"#a5f3fc",
+		"#67e8f9",
+		"#22d3ee",
+		"#06b6d4",
+		"#0891b2",
+		"#0e7490",
+		"#155e75",
+		"#164e63",
+		"#083344"
+	],
+	sky: [
+		"#f0f9ff",
+		"#e0f2fe",
+		"#bae6fd",
+		"#7dd3fc",
+		"#38bdf8",
+		"#0ea5e9",
+		"#0284c7",
+		"#0369a1",
+		"#075985",
+		"#0c4a6e",
+		"#082f49"
+	],
+	blue: [
+		"#eff6ff",
+		"#dbeafe",
+		"#bfdbfe",
+		"#93c5fd",
+		"#60a5fa",
+		"#3b82f6",
+		"#2563eb",
+		"#1d4ed8",
+		"#1e40af",
+		"#1e3a8a",
+		"#172554"
+	],
+	indigo: [
+		"#eef2ff",
+		"#e0e7ff",
+		"#c7d2fe",
+		"#a5b4fc",
+		"#818cf8",
+		"#6366f1",
+		"#4f46e5",
+		"#4338ca",
+		"#3730a3",
+		"#312e81",
+		"#1e1b4b"
+	],
+	violet: [
+		"#f5f3ff",
+		"#ede9fe",
+		"#ddd6fe",
+		"#c4b5fd",
+		"#a78bfa",
+		"#8b5cf6",
+		"#7c3aed",
+		"#6d28d9",
+		"#5b21b6",
+		"#4c1d95",
+		"#2e1065"
+	],
+	purple: [
+		"#faf5ff",
+		"#f3e8ff",
+		"#e9d5ff",
+		"#d8b4fe",
+		"#c084fc",
+		"#a855f7",
+		"#9333ea",
+		"#7e22ce",
+		"#6b21a8",
+		"#581c87",
+		"#3b0764"
+	],
+	fuchsia: [
+		"#fdf4ff",
+		"#fae8ff",
+		"#f5d0fe",
+		"#f0abfc",
+		"#e879f9",
+		"#d946ef",
+		"#c026d3",
+		"#a21caf",
+		"#86198f",
+		"#701a75",
+		"#4a044e"
+	],
+	pink: [
+		"#fdf2f8",
+		"#fce7f3",
+		"#fbcfe8",
+		"#f9a8d4",
+		"#f472b6",
+		"#ec4899",
+		"#db2777",
+		"#be185d",
+		"#9d174d",
+		"#831843",
+		"#500724"
+	],
+	rose: [
+		"#fff1f2",
+		"#ffe4e6",
+		"#fecdd3",
+		"#fda4af",
+		"#fb7185",
+		"#f43f5e",
+		"#e11d48",
+		"#be123c",
+		"#9f1239",
+		"#881337",
+		"#4c0519"
+	]
+};
+function createTailwindV3DefaultColorThemeCss() {
+	const declarations = ["  --color-black: #000;", "  --color-white: #fff;"];
+	for (const [color, values] of Object.entries(TAILWIND_V3_COLOR_PALETTE)) for (let index = 0; index < TAILWIND_V3_COLOR_STEPS.length; index++) declarations.push(`  --color-${color}-${TAILWIND_V3_COLOR_STEPS[index]}: ${values[index]};`);
+	return [
+		"@theme {",
+		...declarations,
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/tailwind-v3-compatibility.ts
+const TAILWIND_V3_COMPATIBILITY_THEME_CSS = [
+	"@theme {",
+	"  --default-ring-width: 3px;",
+	"  --default-ring-color: var(--color-blue-500, #3b82f6);",
+	"  --default-outline-width: 3px;",
+	"",
+	"  --shadow-xs: 0 1px rgb(0 0 0 / 0.05);",
+	"  --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);",
+	"  --shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);",
+	"  --drop-shadow-xs: 0 1px 1px rgb(0 0 0 / 0.05);",
+	"  --drop-shadow-sm: 0 1px 2px rgb(0 0 0 / 0.15);",
+	"  --drop-shadow: 0 1px 2px rgb(0 0 0 / 0.1), 0 1px 1px rgb(0 0 0 / 0.06);",
+	"",
+	"  --blur-xs: 4px;",
+	"  --blur-sm: 4px;",
+	"  --blur: 8px;",
+	"  --backdrop-blur-xs: 4px;",
+	"  --backdrop-blur-sm: 4px;",
+	"  --backdrop-blur: 8px;",
+	"",
+	"  --radius-xs: 0.125rem;",
+	"  --radius-sm: 0.125rem;",
+	"  --radius: 0.25rem;",
+	"}",
+	createTailwindV3DefaultColorThemeCss()
+].join("\n");
+const TAILWIND_V3_COMPATIBILITY_BASE_CSS = [
+	"*,",
+	"::after,",
+	"::before,",
+	"::backdrop,",
+	"::file-selector-button {",
+	"  border-color: var(--color-gray-200, currentcolor);",
+	"}",
+	"",
+	"input::placeholder,",
+	"textarea::placeholder {",
+	"  opacity: 1;",
+	"  color: var(--color-gray-400, currentcolor);",
+	"}",
+	"",
+	"button:not(:disabled),",
+	"[role=\"button\"]:not(:disabled) {",
+	"  cursor: pointer;",
+	"}",
+	"",
+	"dialog {",
+	"  margin: auto;",
+	"}"
+].join("\n");
+function applyTailwindV3CompatibilityCss(css) {
+	return `${TAILWIND_V3_COMPATIBILITY_THEME_CSS}\n${css}\n${TAILWIND_V3_COMPATIBILITY_BASE_CSS}`;
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/tailwind-v4-default-colors.ts
+const TAILWIND_V4_COLOR_STEPS = [
+	"50",
+	"100",
+	"200",
+	"300",
+	"400",
+	"500",
+	"600",
+	"700",
+	"800",
+	"900",
+	"950"
+];
+const TAILWIND_V4_COLOR_PALETTE = {
+	slate: [
+		"#f8fafc",
+		"#f1f5f9",
+		"#e2e8f0",
+		"#cad5e2",
+		"#90a1b9",
+		"#62748e",
+		"#45556c",
+		"#314158",
+		"#1d293d",
+		"#0f172b",
+		"#020618"
+	],
+	gray: [
+		"#f9fafb",
+		"#f3f4f6",
+		"#e5e7eb",
+		"#d1d5dc",
+		"#99a1af",
+		"#6a7282",
+		"#4a5565",
+		"#364153",
+		"#1e2939",
+		"#101828",
+		"#030712"
+	],
+	zinc: [
+		"#fafafa",
+		"#f4f4f5",
+		"#e4e4e7",
+		"#d4d4d8",
+		"#9f9fa9",
+		"#71717b",
+		"#52525c",
+		"#3f3f46",
+		"#27272a",
+		"#18181b",
+		"#09090b"
+	],
+	neutral: [
+		"#fafafa",
+		"#f5f5f5",
+		"#e5e5e5",
+		"#d4d4d4",
+		"#a1a1a1",
+		"#737373",
+		"#525252",
+		"#404040",
+		"#262626",
+		"#171717",
+		"#0a0a0a"
+	],
+	stone: [
+		"#fafaf9",
+		"#f5f5f4",
+		"#e7e5e4",
+		"#d6d3d1",
+		"#a6a09b",
+		"#79716b",
+		"#57534d",
+		"#44403b",
+		"#292524",
+		"#1c1917",
+		"#0c0a09"
+	],
+	mauve: [
+		"#fafafa",
+		"#f3f1f3",
+		"#e7e4e7",
+		"#d7d0d7",
+		"#a89ea9",
+		"#79697b",
+		"#594c5b",
+		"#463947",
+		"#2a212c",
+		"#1d161e",
+		"#0c090c"
+	],
+	olive: [
+		"#fbfbf9",
+		"#f4f4f0",
+		"#e8e8e3",
+		"#d8d8d0",
+		"#abab9c",
+		"#7c7c67",
+		"#5b5b4b",
+		"#474739",
+		"#2b2b22",
+		"#1d1d16",
+		"#0c0c09"
+	],
+	mist: [
+		"#f9fbfb",
+		"#f1f3f3",
+		"#e3e7e8",
+		"#d0d6d8",
+		"#9ca8ab",
+		"#67787c",
+		"#4b585b",
+		"#394447",
+		"#22292b",
+		"#161b1d",
+		"#090b0c"
+	],
+	taupe: [
+		"#fbfaf9",
+		"#f3f1f1",
+		"#e8e4e3",
+		"#d8d2d0",
+		"#aba09c",
+		"#7c6d67",
+		"#5b4f4b",
+		"#473c39",
+		"#2b2422",
+		"#1d1816",
+		"#0c0a09"
+	],
+	red: [
+		"#fef2f2",
+		"#ffe2e2",
+		"#ffc9c9",
+		"#ffa2a2",
+		"#ff6467",
+		"#fb2c36",
+		"#e7000b",
+		"#c10007",
+		"#9f0712",
+		"#82181a",
+		"#460809"
+	],
+	orange: [
+		"#fff7ed",
+		"#ffedd4",
+		"#ffd6a7",
+		"#ffb86a",
+		"#ff8904",
+		"#ff6900",
+		"#f54900",
+		"#ca3500",
+		"#9f2d00",
+		"#7e2a0c",
+		"#441306"
+	],
+	amber: [
+		"#fffbeb",
+		"#fef3c6",
+		"#fee685",
+		"#ffd230",
+		"#ffb900",
+		"#fe9a00",
+		"#e17100",
+		"#bb4d00",
+		"#973c00",
+		"#7b3306",
+		"#461901"
+	],
+	yellow: [
+		"#fefce8",
+		"#fef9c2",
+		"#fff085",
+		"#ffdf20",
+		"#fdc700",
+		"#f0b100",
+		"#d08700",
+		"#a65f00",
+		"#894b00",
+		"#733e0a",
+		"#432004"
+	],
+	lime: [
+		"#f7fee7",
+		"#ecfcca",
+		"#d8f999",
+		"#bbf451",
+		"#9ae600",
+		"#7ccf00",
+		"#5ea500",
+		"#497d00",
+		"#3c6300",
+		"#35530e",
+		"#192e03"
+	],
+	green: [
+		"#f0fdf4",
+		"#dcfce7",
+		"#b9f8cf",
+		"#7bf1a8",
+		"#05df72",
+		"#00c950",
+		"#00a63e",
+		"#008236",
+		"#016630",
+		"#0d542b",
+		"#032e15"
+	],
+	emerald: [
+		"#ecfdf5",
+		"#d0fae5",
+		"#a4f4cf",
+		"#5ee9b5",
+		"#00d492",
+		"#00bc7d",
+		"#009966",
+		"#007a55",
+		"#006045",
+		"#004f3b",
+		"#002c22"
+	],
+	teal: [
+		"#f0fdfa",
+		"#cbfbf1",
+		"#96f7e4",
+		"#46ecd5",
+		"#00d5be",
+		"#00bba7",
+		"#009689",
+		"#00786f",
+		"#005f5a",
+		"#0b4f4a",
+		"#022f2e"
+	],
+	cyan: [
+		"#ecfeff",
+		"#cefafe",
+		"#a2f4fd",
+		"#53eafd",
+		"#00d3f2",
+		"#00b8db",
+		"#0092b8",
+		"#007595",
+		"#005f78",
+		"#104e64",
+		"#053345"
+	],
+	sky: [
+		"#f0f9ff",
+		"#dff2fe",
+		"#b8e6fe",
+		"#74d4ff",
+		"#00bcff",
+		"#00a6f4",
+		"#0084d1",
+		"#0069a8",
+		"#00598a",
+		"#024a70",
+		"#052f4a"
+	],
+	blue: [
+		"#eff6ff",
+		"#dbeafe",
+		"#bedbff",
+		"#8ec5ff",
+		"#51a2ff",
+		"#2b7fff",
+		"#155dfc",
+		"#1447e6",
+		"#193cb8",
+		"#1c398e",
+		"#162456"
+	],
+	indigo: [
+		"#eef2ff",
+		"#e0e7ff",
+		"#c6d2ff",
+		"#a3b3ff",
+		"#7c86ff",
+		"#615fff",
+		"#4f39f6",
+		"#432dd7",
+		"#372aac",
+		"#312c85",
+		"#1e1a4d"
+	],
+	violet: [
+		"#f5f3ff",
+		"#ede9fe",
+		"#ddd6ff",
+		"#c4b4ff",
+		"#a684ff",
+		"#8e51ff",
+		"#7f22fe",
+		"#7008e7",
+		"#5d0ec0",
+		"#4d179a",
+		"#2f0d68"
+	],
+	purple: [
+		"#faf5ff",
+		"#f3e8ff",
+		"#e9d4ff",
+		"#dab2ff",
+		"#c27aff",
+		"#ad46ff",
+		"#9810fa",
+		"#8200db",
+		"#6e11b0",
+		"#59168b",
+		"#3c0366"
+	],
+	fuchsia: [
+		"#fdf4ff",
+		"#fae8ff",
+		"#f6cfff",
+		"#f4a8ff",
+		"#ed6aff",
+		"#e12afb",
+		"#c800de",
+		"#a800b7",
+		"#8a0194",
+		"#721378",
+		"#4b004f"
+	],
+	pink: [
+		"#fdf2f8",
+		"#fce7f3",
+		"#fccee8",
+		"#fda5d5",
+		"#fb64b6",
+		"#f6339a",
+		"#e60076",
+		"#c6005c",
+		"#a3004c",
+		"#861043",
+		"#510424"
+	],
+	rose: [
+		"#fff1f2",
+		"#ffe4e6",
+		"#ffccd3",
+		"#ffa1ad",
+		"#ff637e",
+		"#ff2056",
+		"#ec003f",
+		"#c70036",
+		"#a50036",
+		"#8b0836",
+		"#4d0218"
+	]
+};
+function createTailwindV4DefaultColorThemeCss() {
+	const declarations = ["  --color-black: #000;", "  --color-white: #fff;"];
+	for (const [color, values] of Object.entries(TAILWIND_V4_COLOR_PALETTE)) for (let index = 0; index < TAILWIND_V4_COLOR_STEPS.length; index++) declarations.push(`  --color-${color}-${TAILWIND_V4_COLOR_STEPS[index]}: ${values[index]};`);
+	return [
+		"@theme {",
+		...declarations,
+		"}"
+	].join("\n");
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/generator.ts
+const incrementalGenerateCache$1 = /* @__PURE__ */ new Map();
+const incrementalGenerateTaskCache = /* @__PURE__ */ new Map();
+function findLeadingImportInsertionIndex(css) {
+	const importPattern = /(?:^|\n)\s*@import\b[^;]*;/g;
+	let insertionIndex = 0;
+	let match = importPattern.exec(css);
+	while (match !== null) {
+		insertionIndex = match.index + match[0].length;
+		match = importPattern.exec(css);
+	}
+	return insertionIndex;
+}
+function applyMiniProgramTailwindV4DefaultColorCss(css) {
+	const themeCss = createTailwindV4DefaultColorThemeCss();
+	const insertionIndex = findLeadingImportInsertionIndex(css);
+	if (insertionIndex === 0) return `${themeCss}\n${css}`;
+	return `${css.slice(0, insertionIndex)}\n${themeCss}\n${css.slice(insertionIndex)}`;
+}
+function collectCandidates$1(candidates) {
+	return new Set(candidates ?? []);
+}
+function createStableJson$1(value) {
+	if (value === void 0) return "undefined";
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => createStableJson$1(item)).join(",")}]`;
+	return `{${Object.keys(value).sort().map((key) => {
+		const record = value;
+		return `${JSON.stringify(key)}:${createStableJson$1(record[key])}`;
+	}).join(",")}}`;
+}
+function createDependencyFingerprint$1(files) {
+	return files.map((file) => {
+		try {
+			const stat = fs.statSync(file);
+			return `${file}:${stat.size}:${stat.mtimeMs}`;
+		} catch {
+			return `${file}:missing`;
+		}
+	}).join("|");
+}
+function createIncrementalGenerateCacheKey$1(source, target, styleOptions, tailwindcssV3Compatibility) {
+	return [
+		source.projectRoot,
+		source.base,
+		createStableJson$1(source.baseFallbacks),
+		source.css,
+		createDependencyFingerprint$1(source.dependencies),
+		target,
+		createStableJson$1(styleOptions),
+		createStableJson$1(tailwindcssV3Compatibility)
+	].join("\0");
+}
+function createIncrementalGenerateTaskCacheKey(cacheKey, requestedCandidates, scanSources) {
+	return [
+		cacheKey,
+		scanSources === true ? "scan:1" : "scan:0",
+		[...requestedCandidates].sort().join("\n")
+	].join("\0");
+}
+function runIncrementalGenerateTask(cacheKey, requestedCandidates, scanSources, task) {
+	const taskKey = createIncrementalGenerateTaskCacheKey(cacheKey, requestedCandidates, scanSources);
+	const cachedTask = incrementalGenerateTaskCache.get(taskKey);
+	if (cachedTask) return cachedTask;
+	const promise = task();
+	incrementalGenerateTaskCache.set(taskKey, promise);
+	promise.finally(() => {
+		if (incrementalGenerateTaskCache.get(taskKey) === promise) incrementalGenerateTaskCache.delete(taskKey);
+	});
+	return promise;
+}
+function createIncrementalDesignSystemPromise(source, cacheKey) {
+	const promise = loadTailwindV4DesignSystem(source);
+	promise.catch(() => {
+		if (incrementalGenerateCache$1.get(cacheKey)?.designSystemPromise === promise) incrementalGenerateCache$1.delete(cacheKey);
+	});
+	return promise;
+}
+function createCompatibleSource(source, target, tailwindcssV3Compatibility) {
+	const shouldApplyTailwindV3Compatibility = tailwindcssV3Compatibility ?? target === "weapp";
+	const filteredSourceCss = target === "weapp" ? removeUnlayeredTailwindV4PreflightImports(source.css) : source.css;
+	const compatibleSourceCss = removeUnsupportedThemeVendorKeyframes(shouldApplyTailwindV3Compatibility ? applyTailwindV3CompatibilityCss(filteredSourceCss) : target === "weapp" ? applyMiniProgramTailwindV4DefaultColorCss(filteredSourceCss) : filteredSourceCss);
+	return compatibleSourceCss === source.css ? source : {
+		...source,
+		css: compatibleSourceCss
+	};
+}
+function resolveTargetCandidates(candidates, target) {
+	const collected = collectCandidates$1(candidates);
+	return target === "weapp" ? filterUnsupportedMiniProgramTailwindV4Candidates(collected) : collected;
+}
+function collectSeenCandidates(generated, requestedCandidates) {
+	return new Set([
+		...requestedCandidates,
+		...generated.rawCandidates,
+		...generated.classSet
+	]);
+}
+function seedIncrementalGenerateCache(options) {
+	const cacheKey = createIncrementalGenerateCacheKey$1(options.compatibleSource, options.target, options.styleOptions, options.tailwindcssV3Compatibility);
+	incrementalGenerateCache$1.set(cacheKey, {
+		seenCandidates: collectSeenCandidates(options.generated, options.requestedCandidates),
+		classSet: new Set(options.generated.classSet),
+		css: options.generated.css,
+		rawCss: options.generated.rawCss,
+		designSystemPromise: createIncrementalDesignSystemPromise(options.compatibleSource, cacheKey),
+		dependencies: options.generated.dependencies,
+		sources: options.generated.sources,
+		root: options.generated.root,
+		target: options.generated.target
+	});
+}
+function parseImportSourceParam$1(params) {
+	const match = /\bsource\(\s*(none|(['"])(.*?)\2)\s*\)/.exec(params);
+	if (!match) return;
+	return {
+		none: match[1] === "none",
+		sourcePath: match[3]
+	};
+}
+function isTailwindCssImport$1(params) {
+	return /^\s*(['"])tailwindcss(?:\/[^'"]*)?\1/.test(params);
+}
+function parseCssImportSpecifier$1(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 isTailwindCssPreflightImport(params) {
+	const specifier = parseCssImportSpecifier$1(params);
+	return specifier === "tailwindcss/preflight.css" || specifier === "tailwindcss/preflight";
+}
+function hasImportLayerOption(params) {
+	return /\blayer(?:\s*\(|\s*$)/.test(params);
+}
+function removeUnlayeredTailwindV4PreflightImports(css) {
+	if (!css.includes("preflight")) return css;
+	let root;
+	try {
+		root = postcss.parse(css);
+	} catch {
+		return css;
+	}
+	let changed = false;
+	root.walkAtRules("import", (rule) => {
+		if (isTailwindCssPreflightImport(rule.params) && !hasImportLayerOption(rule.params)) {
+			rule.remove();
+			changed = true;
+		}
+	});
+	return changed ? root.toString() : css;
+}
+function parseSourceFileParam(params) {
+	const value = params.trim();
+	if (!value || value === "none" || value.startsWith("inline(")) return;
+	const negated = value.startsWith("not ");
+	const sourceValue = negated ? value.slice(4).trim() : value;
+	if (sourceValue.startsWith("inline(")) return;
+	const match = /^(['"])(.+)\1$/.exec(sourceValue);
+	return match?.[2] ? {
+		negated,
+		pattern: match[2]
+	} : void 0;
+}
+function resolveSourceBase$1(base, sourcePath) {
+	return path.isAbsolute(sourcePath) ? sourcePath : path.resolve(base, sourcePath);
+}
+function resolveCssDefinedScanSources(source) {
+	let importSourceBase;
+	let hasSourceNone = false;
+	const sourcePatterns = [];
+	const from = source.dependencies[0];
+	let root;
+	try {
+		root = postcss.parse(source.css, { from });
+	} catch {
+		return;
+	}
+	root.walkAtRules((rule) => {
+		if (rule.name === "import") {
+			if (!isTailwindCssImport$1(rule.params)) return;
+			const sourceParam = parseImportSourceParam$1(rule.params);
+			if (sourceParam?.none) hasSourceNone = true;
+			if (sourceParam?.sourcePath) importSourceBase = resolveSourceBase$1(source.base, sourceParam.sourcePath);
+			return;
+		}
+		if (rule.name !== "source") return;
+		const sourcePattern = parseSourceFileParam(rule.params);
+		if (!sourcePattern) return;
+		sourcePatterns.push({
+			base: source.base,
+			negated: sourcePattern.negated,
+			pattern: sourcePattern.pattern
+		});
+	});
+	if (!importSourceBase) {
+		if (hasSourceNone) return sourcePatterns.length > 0 ? sourcePatterns : false;
+		return;
+	}
+	return [{
+		base: importSourceBase,
+		negated: false,
+		pattern: "**/*"
+	}, ...sourcePatterns];
+}
+function resolveScanSources(source, scanSources) {
+	if (scanSources !== true) return scanSources;
+	return resolveCssDefinedScanSources(source) ?? scanSources;
+}
+function hasThemeParent(rule) {
+	let parent = rule.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name === "theme") return true;
+		parent = parent.parent;
+	}
+	return false;
+}
+function isVendorPrefixedKeyframes(rule) {
+	return rule.name.startsWith("-") && rule.name.endsWith("keyframes");
+}
+function removeUnsupportedThemeVendorKeyframes(css) {
+	if (!css.includes("@theme") || !css.includes("@-")) return css;
+	let root;
+	try {
+		root = postcss.parse(css);
+	} catch {
+		return css;
+	}
+	let changed = false;
+	root.walkAtRules((rule) => {
+		if (isVendorPrefixedKeyframes(rule) && hasThemeParent(rule)) {
+			rule.remove();
+			changed = true;
+		}
+	});
+	return changed ? root.toString() : css;
+}
+function createTailwindV4Engine$1(source) {
+	async function generateOnce(generateSource, options = {}) {
+		const { scanSources = true, styleOptions, tailwindcssV3Compatibility, target = "weapp", ...patchOptions } = options;
+		const compatibleSource = createCompatibleSource(generateSource, target, tailwindcssV3Compatibility);
+		const candidates = resolveTargetCandidates(patchOptions.candidates, target);
+		const result = await createTailwindV4Engine(compatibleSource).generate(omitUndefined({
+			scanSources: resolveScanSources(compatibleSource, scanSources),
+			...patchOptions,
+			candidates
+		}));
+		const rawCss = result.css;
+		const css = await transformTailwindV4CssByTarget(rawCss, target, styleOptions);
+		return {
+			...result,
+			css,
+			rawCss,
+			target
+		};
+	}
+	async function generateWithIncrementalCache(options = {}) {
+		const target = options.target ?? "weapp";
+		const compatibleSource = createCompatibleSource(source, target, options.tailwindcssV3Compatibility);
+		const requestedCandidates = resolveTargetCandidates(options.candidates, target);
+		if ((options.sources?.length ?? 0) > 0 || options.bareArbitraryValues !== void 0 || Array.isArray(options.scanSources)) return generateOnce(source, options);
+		const cacheKey = createIncrementalGenerateCacheKey$1(compatibleSource, target, options.styleOptions, options.tailwindcssV3Compatibility);
+		if (options.scanSources === true) return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+			const generated = await generateOnce(source, options);
+			seedIncrementalGenerateCache({
+				compatibleSource,
+				generated,
+				requestedCandidates,
+				styleOptions: options.styleOptions,
+				tailwindcssV3Compatibility: options.tailwindcssV3Compatibility,
+				target
+			});
+			return generated;
+		});
+		const cached = incrementalGenerateCache$1.get(cacheKey);
+		if (cached) {
+			const missingCandidates = [...requestedCandidates].filter((candidate) => !cached.seenCandidates.has(candidate));
+			if (missingCandidates.length === 0) return {
+				css: cached.css,
+				rawCss: cached.rawCss,
+				incrementalCss: "",
+				incrementalRawCss: "",
+				classSet: new Set(cached.classSet),
+				rawCandidates: new Set(cached.seenCandidates),
+				dependencies: cached.dependencies,
+				sources: cached.sources,
+				root: cached.root,
+				target: cached.target
+			};
+			return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+				const cssByCandidate = (await cached.designSystemPromise).candidatesToCss(missingCandidates);
+				const rawCssParts = [];
+				const classSet = /* @__PURE__ */ new Set();
+				for (let index = 0; index < missingCandidates.length; index += 1) {
+					const candidate = missingCandidates[index];
+					const css = cssByCandidate[index];
+					if (candidate && typeof css === "string" && css.trim().length > 0) {
+						rawCssParts.push(css);
+						classSet.add(candidate);
+					}
+				}
+				const rawCss = rawCssParts.join("\n");
+				const incrementalCss = rawCss.length > 0 ? await transformTailwindV4CssByTarget(rawCss, target, options.styleOptions) : "";
+				for (const candidate of missingCandidates) cached.seenCandidates.add(candidate);
+				for (const className of classSet) cached.classSet.add(className);
+				cached.css = [cached.css, incrementalCss].filter(Boolean).join("\n");
+				cached.rawCss = [cached.rawCss, rawCss].filter(Boolean).join("\n");
+				return {
+					css: cached.css,
+					rawCss: cached.rawCss,
+					incrementalCss,
+					incrementalRawCss: rawCss,
+					classSet: new Set(cached.classSet),
+					rawCandidates: new Set(cached.seenCandidates),
+					dependencies: cached.dependencies,
+					sources: cached.sources,
+					root: cached.root,
+					target: cached.target
+				};
+			});
+		}
+		return runIncrementalGenerateTask(cacheKey, requestedCandidates, options.scanSources, async () => {
+			const generated = await generateOnce(source, options);
+			seedIncrementalGenerateCache({
+				compatibleSource,
+				generated,
+				requestedCandidates,
+				styleOptions: options.styleOptions,
+				tailwindcssV3Compatibility: options.tailwindcssV3Compatibility,
+				target
+			});
+			return generated;
+		});
+	}
+	async function generate(options = {}) {
+		return options.incrementalCache ? generateWithIncrementalCache(options) : generateOnce(source, options);
+	}
+	return {
+		source,
+		loadDesignSystem: createTailwindV4Engine(source).loadDesignSystem,
+		validateCandidates: createTailwindV4Engine(source).validateCandidates,
+		generate
+	};
+}
+//#endregion
+//#region src/tailwindcss/v4-engine/source.ts
+function isPostcssPluginImportTarget(value) {
+	if (!value) return false;
+	return value === "@tailwindcss/postcss" || value.includes("/postcss");
+}
+function uniqueDefined(values) {
+	return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))];
+}
+function getProjectRoot$1(patcher) {
+	return patcher.options?.projectRoot ?? process.cwd();
+}
+function readConfiguredV4Base(tailwindOptions) {
+	const v4 = typeof tailwindOptions === "object" && tailwindOptions !== null ? tailwindOptions : void 0;
+	if (typeof v4 !== "object" || v4 === null) return;
+	return v4.configuredBase;
+}
+function isBarePackageSpecifier(specifier) {
+	return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.includes("\\") && !/^[a-z][a-z\d+.-]*:/i.test(specifier);
+}
+function parseCssImportSpecifier(params) {
+	const value = params.trim();
+	const quoted = /^(['"])(.*?)\1/.exec(value);
+	if (quoted) {
+		const specifier = quoted[2];
+		if (specifier === void 0) return;
+		return {
+			quote: quoted[1],
+			raw: quoted[0],
+			specifier
+		};
+	}
+	const url = /^url\(\s*(?:(['"])(.*?)\1|([^'")\s]+))\s*\)/.exec(value);
+	if (!url) return;
+	const specifier = url[2] ?? url[3];
+	if (specifier === void 0) return;
+	return {
+		quote: url[1],
+		raw: url[0],
+		specifier
+	};
+}
+function quoteCssImportSpecifier(specifier, quote = "\"") {
+	return `${quote}${specifier.replaceAll("\\", "\\\\").replaceAll(quote, `\\${quote}`)}${quote}`;
+}
+function createTailwindV4CssImportSpecifierSet(packageName) {
+	const specifiers = new Set(["tailwindcss"]);
+	if (packageName && isBarePackageSpecifier(packageName)) specifiers.add(packageName);
+	return specifiers;
+}
+function normalizeTailwindV4CssPackageImports(css, packageName) {
+	if (!css.includes("tailwindcss")) return css;
+	let root;
+	try {
+		root = postcss.parse(css);
+	} catch {
+		return css;
+	}
+	const importSpecifiers = createTailwindV4CssImportSpecifierSet(packageName);
+	let changed = false;
+	root.walkAtRules("import", (rule) => {
+		const parsed = parseCssImportSpecifier(rule.params);
+		if (!parsed || !importSpecifiers.has(parsed.specifier)) return;
+		rule.params = rule.params.replace(parsed.raw, quoteCssImportSpecifier(`${parsed.specifier}/index.css`, parsed.quote));
+		changed = true;
+	});
+	return changed ? root.toString() : css;
+}
+function resolveTailwindCssImportTarget(patcher) {
+	const configuredPackageName = resolveTailwindcssOptions(patcher.options)?.packageName;
+	if (typeof configuredPackageName === "string" && configuredPackageName.length > 0 && !isPostcssPluginImportTarget(configuredPackageName)) return configuredPackageName;
+	const packageName = patcher.packageInfo?.name;
+	if (typeof packageName === "string" && packageName.length > 0 && !isPostcssPluginImportTarget(packageName)) return packageName;
+	return "tailwindcss";
+}
+function readTailwindV4Options(patcher) {
+	return resolveTailwindcssOptions(patcher.options)?.v4 ?? patcher.options?.tailwind?.v4;
+}
+function resolveTailwindV4SourceOptionsFromPatcher(patcher) {
+	const projectRoot = getProjectRoot$1(patcher);
+	const tailwindOptions = resolveTailwindcssOptions(patcher.options);
+	const tailwindV4Options = readTailwindV4Options(patcher);
+	const configDir = tailwindOptions?.config ? path.dirname(tailwindOptions.config) : void 0;
+	const configuredBase = readConfiguredV4Base(tailwindV4Options);
+	const hasCssEntries = Boolean(tailwindV4Options?.cssEntries?.length);
+	return omitUndefined({
+		projectRoot,
+		base: configuredBase ?? (hasCssEntries ? void 0 : tailwindV4Options?.base),
+		baseFallbacks: uniqueDefined([tailwindOptions?.cwd, configDir]),
+		css: tailwindV4Options?.css,
+		cssSources: tailwindV4Options?.cssSources,
+		cssEntries: tailwindV4Options?.cssEntries,
+		sources: tailwindV4Options?.sources,
+		packageName: resolveTailwindCssImportTarget(patcher)
+	});
+}
+function resolveTailwindV4Source$1(options) {
+	return resolveTailwindV4Source(options?.css === void 0 ? options : {
+		...options,
+		css: normalizeTailwindV4CssPackageImports(options.css, options.packageName)
+	});
+}
+async function resolveTailwindV4SourceFromPatcher(patcher) {
+	return resolveTailwindV4Source$1(resolveTailwindV4SourceOptionsFromPatcher(patcher));
+}
+//#endregion
+//#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.ts
+const VITE_SOURCE_CANDIDATE_PATTERN = createSourceScanPattern([
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts",
+	"vue",
+	"uvue",
+	"nvue",
+	"svelte",
+	"mpx",
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"css",
+	"wxss",
+	"acss",
+	"jxss",
+	"ttss",
+	"qss",
+	"tyss",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+]);
+const VITE_TAILWIND_CSS_ENTRY_PATTERN = "**/*.{css,less,sass,scss,styl,stylus,pcss,postcss}";
+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 isTailwindCssImport(params) {
+	return /^\s*(['"])tailwindcss(?:\/[^'"]*)?\1/.test(params);
+}
+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);
+	let current = path.resolve(base);
+	while (true) {
+		const candidate = path.resolve(current, configPath);
+		if (existsSync(candidate)) return candidate;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return path.resolve(base, configPath);
+}
+function createCssEntriesCacheKey(css, base, dependencies) {
+	return JSON.stringify({
+		base: path.resolve(base),
+		css,
+		dependencies
+	});
+}
+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);
+}
+function createResolvedViteSourceScan(input, dependencies) {
+	return {
+		...input,
+		...dependencies.size > 0 ? { dependencies: [...dependencies].sort() } : {}
+	};
+}
+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$1(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$1(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)));
+			continue;
+		}
+		try {
+			const loaded = await loadConfig({
+				config: configPath,
+				cwd: path.dirname(configPath)
+			});
+			entries.push(...normalizeLegacyContentEntries(loaded?.config.content, 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;
+	const [sourceEntries, configEntries] = await Promise.all([resolveCssSourceEntries(root, base, VITE_SOURCE_CANDIDATE_PATTERN), resolveConfigContentEntries(root, base)]);
+	const entries = [...configEntries.entries, ...sourceEntries];
+	const inlineCandidates = collectCssInlineSourceCandidates(root);
+	root.walkAtRules("import", (rule) => {
+		if (!isTailwindCssImport(rule.params)) return;
+		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
+	};
+	return entries.length > 0 ? {
+		entries,
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	} : inlineCandidates.included.size > 0 || inlineCandidates.excluded.size > 0 ? {
+		entries: [],
+		explicit: true,
+		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.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssEntries ?? []
+	].filter((item) => typeof item === "string" && item.length > 0).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);
+	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 [...options.tailwindcss?.v4?.cssSources ?? [], ...options.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssSources ?? []];
+}
+function resolveTailwindV4CssSourceBase(source, fallbackBase) {
+	if (typeof source.base === "string" && source.base.length > 0) return source.base;
+	if (typeof source.file === "string" && source.file.length > 0) return path.dirname(source.file);
+	return fallbackBase;
+}
+async function resolveViteSourceScanEntries(options, patcher, scanOptions = {}) {
+	if (patcher.majorVersion === 3) {
+		const source = await resolveTailwindV3SourceFromPatcher(patcher);
+		const contentEntries = normalizeLegacyContentEntries(source.configObject?.content, source.config ? path.dirname(source.config) : source.cwd);
+		const dependencies = /* @__PURE__ */ new Set();
+		addSourceScanDependency(dependencies, source.config);
+		return contentEntries.length > 0 ? createResolvedViteSourceScan({ entries: contentEntries }, dependencies) : void 0;
+	}
+	if (patcher.majorVersion === 4) {
+		const sourceOptions = resolveTailwindV4SourceOptionsFromPatcher(patcher);
+		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;
+		for (const cssEntry of cssEntries) {
+			addSourceScanDependency(dependencies, cssEntry);
+			const resolved = await resolveTailwindV4EntriesFromCssCached(readFileSync(cssEntry, "utf8"), 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);
+		if (entries.length > 0 || inlineCandidates || explicit) return createResolvedViteSourceScan({
+			entries: explicit ? entries : entries.length > 0 ? entries : 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({
+				entries: resolved.entries,
+				explicit: resolved.explicit,
+				inlineCandidates: resolved.inlineCandidates
+			}, new Set(resolved.dependencies)) : void 0;
+		}
+		const sourceOptionBase = sourceOptions.base ?? sourceOptions.projectRoot ?? process.cwd();
+		for (const cssSource of [...collectConfiguredCssSources(options), ...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);
+		if (entries.length > 0 || cssSourceInlineCandidates || explicit) return createResolvedViteSourceScan({
+			entries: explicit ? entries : entries.length > 0 ? entries : void 0,
+			explicit,
+			inlineCandidates: cssSourceInlineCandidates
+		}, dependencies);
+		const source = await resolveTailwindV4SourceFromPatcher(patcher);
+		addSourceScanDependency(dependencies, source.file);
+		addSourceScanDependencies(dependencies, source.dependencies);
+		const resolved = await resolveTailwindV4EntriesFromCssCached(source.css, source.base);
+		return resolved ? createResolvedViteSourceScan({
+			entries: resolved.entries,
+			explicit: resolved.explicit,
+			inlineCandidates: resolved.inlineCandidates
+		}, new Set([...dependencies, ...resolved.dependencies])) : void 0;
+	}
+}
+function toPosixPath(value) {
+	return value.split(path.sep).join("/");
+}
+function normalizeEntryPattern(entry) {
+	return path.isAbsolute(entry.pattern) ? toPosixPath(path.relative(path.resolve(entry.base), entry.pattern)) : entry.pattern;
+}
+function createViteSourceScanMatcher(entries) {
+	if (!entries?.length) return;
+	const positiveEntries = entries.filter((entry) => !entry.negated);
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	if (positiveEntries.length === 0) return () => false;
+	return (file) => {
+		const resolvedFile = path.resolve(file);
+		if (!positiveEntries.some((entry) => {
+			const relative = toPosixPath(path.relative(path.resolve(entry.base), resolvedFile));
+			return relative && !relative.startsWith("../") && !path.isAbsolute(relative) && micromatch.isMatch(relative, normalizeEntryPattern(entry));
+		})) return false;
+		return !negativeEntries.some((entry) => {
+			const relative = toPosixPath(path.relative(path.resolve(entry.base), resolvedFile));
+			return relative && !relative.startsWith("../") && !path.isAbsolute(relative) && micromatch.isMatch(relative, normalizeEntryPattern(entry));
+		});
+	};
+}
+//#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 runtimeSignaturePatchersSymbol = Symbol.for("weapp-tailwindcss.runtimeSignaturePatchers");
+function getCacheEntry(twPatcher) {
+	let entry = runtimeClassSetCache.get(twPatcher);
+	if (!entry) {
+		entry = {};
+		runtimeClassSetCache.set(twPatcher, 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(twPatcher) {
+	const tailwindOptions = resolveTailwindcssOptions(twPatcher.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(twPatcher) {
+	const tailwindOptions = resolveTailwindcssOptions(twPatcher.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 ?? twPatcher.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(twPatcher) {
+	const options = twPatcher.options;
+	const tailwindOptions = resolveTailwindcssOptions(options);
+	return normalizeSignatureValue({
+		projectRoot: options?.projectRoot,
+		packageName: tailwindOptions?.packageName,
+		versionHint: readOptionalProperty(tailwindOptions, "versionHint"),
+		cwd: tailwindOptions?.cwd,
+		config: tailwindOptions?.config,
+		v2: tailwindOptions?.v2,
+		v3: tailwindOptions?.v3,
+		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(twPatcher) {
+	const packageInfo = twPatcher.packageInfo;
+	return [
+		packageInfo?.name ?? "missing",
+		packageInfo?.rootPath ?? "missing",
+		packageInfo?.version ?? "unknown",
+		twPatcher.majorVersion ?? "unknown",
+		getTailwindOptionsSignature(twPatcher)
+	].join(":");
+}
+function getNestedPatchers$1(twPatcher) {
+	const nested = twPatcher[runtimeSignaturePatchersSymbol];
+	return Array.isArray(nested) && nested.length > 0 ? nested : void 0;
+}
+function getOwnRuntimeClassSetSignature(twPatcher) {
+	const trackedFiles = [...getTailwindTrackedFiles(twPatcher)].sort((a, b) => a.localeCompare(b)).map(getFileSignature);
+	return `${trackedFiles.length > 0 ? trackedFiles.join("|") : "files:missing"}|runtime:${getRuntimeTargetSignature(twPatcher)}`;
+}
+function invalidateRuntimeClassSet(twPatcher) {
+	if (!twPatcher) return;
+	const nestedPatchers = getNestedPatchers$1(twPatcher);
+	if (nestedPatchers) for (const patcher of nestedPatchers) invalidateRuntimeClassSet(patcher);
+	for (const trackedFile of getTailwindTrackedFiles(twPatcher)) runtimeFileSignatureCache.delete(trackedFile);
+	runtimeTrackedSourceFilesCache.clear();
+	runtimeClassSetCache.delete(twPatcher);
+}
+function getRuntimeClassSetCacheEntry(twPatcher) {
+	return getCacheEntry(twPatcher);
+}
+function getRuntimeClassSetSignature(twPatcher) {
+	const nestedPatchers = getNestedPatchers$1(twPatcher);
+	if (nestedPatchers) return nestedPatchers.map(getOwnRuntimeClassSetSignature).sort((a, b) => a.localeCompare(b)).join("||");
+	return getOwnRuntimeClassSetSignature(twPatcher);
+}
+async function getRuntimeClassSetSignatureWithSources(twPatcher) {
+	const baseSignature = getRuntimeClassSetSignature(twPatcher);
+	if (twPatcher.majorVersion !== 4) return baseSignature;
+	const trackedSourceFiles = await collectTailwindV4TrackedSourceFiles(twPatcher);
+	if (trackedSourceFiles.length === 0) return baseSignature;
+	return [baseSignature, trackedSourceFiles.map(getFileSignature).join("|")].join("|sources:");
+}
+//#endregion
+//#region src/tailwindcss/runtime-patch.ts
+const debug = createDebug("[tailwindcss:runtime-patch] ");
+const require = createRequire(import.meta.url);
+const runtimePatchPromiseCache = /* @__PURE__ */ new WeakMap();
+function getNestedPatchers(twPatcher) {
+	const nested = twPatcher[runtimeSignaturePatchersSymbol];
+	return Array.isArray(nested) && nested.length > 0 ? nested : void 0;
+}
+function shouldApplyRuntimePatch(twPatcher) {
+	return twPatcher.majorVersion === 3 && typeof twPatcher.patch === "function";
+}
+function clearTailwindcssRequireCache(twPatcher) {
+	const rootPath = twPatcher.packageInfo?.rootPath;
+	if (!rootPath) return;
+	const normalizedRoot = path.resolve(rootPath);
+	let count = 0;
+	for (const id of Object.keys(require.cache)) {
+		const normalizedId = path.resolve(id);
+		if (normalizedId === normalizedRoot || normalizedId.startsWith(`${normalizedRoot}${path.sep}`)) {
+			delete require.cache[id];
+			count += 1;
+		}
+	}
+	if (count > 0) debug("clear tailwindcss require cache after runtime patch, count=%d root=%s", count, normalizedRoot);
+}
+async function ensureTailwindcssRuntimePatch(twPatcher, options = {}) {
+	const nestedPatchers = getNestedPatchers(twPatcher);
+	if (nestedPatchers) {
+		await Promise.all(nestedPatchers.map((patcher) => ensureTailwindcssRuntimePatch(patcher)));
+		return;
+	}
+	if (!shouldApplyRuntimePatch(twPatcher)) return;
+	const cached = runtimePatchPromiseCache.get(twPatcher);
+	if (cached) {
+		await cached;
+		if (options.clearRequireCache) clearTailwindcssRequireCache(twPatcher);
+		return;
+	}
+	const task = Promise.resolve().then(async () => {
+		debug("apply tailwindcss runtime patch, package=%s version=%s root=%s", twPatcher.packageInfo?.name ?? "tailwindcss", twPatcher.packageInfo?.version ?? "unknown", twPatcher.packageInfo?.rootPath ?? "unknown");
+		await twPatcher.patch?.();
+		if (options.clearRequireCache) clearTailwindcssRequireCache(twPatcher);
+	}).catch((error) => {
+		runtimePatchPromiseCache.delete(twPatcher);
+		throw error;
+	});
+	runtimePatchPromiseCache.set(twPatcher, task);
+	return task;
+}
+//#endregion
+//#region src/tailwindcss/v3-engine/miniprogram.ts
+const defaultStyleHandler = createStyleHandler({
+	cssChildCombinatorReplaceValue: ["view", "text"],
+	cssRemoveHoverPseudoClass: true,
+	isMainChunk: true,
+	majorVersion: 3
+});
+const MINI_PROGRAM_V3_PREFLIGHT_SELECTOR = "view,text,::before,::after";
+const V3_PREFLIGHT_RESET_PROPS = new Set([
+	"box-sizing",
+	"border",
+	"border-width",
+	"border-style",
+	"border-color",
+	"margin",
+	"padding"
+]);
+function normalizeSelector(selector) {
+	return selector.trim().replace(/\s+/g, "");
+}
+function isMiniProgramV3PreflightRule(rule) {
+	return normalizeSelector(rule.selector) === MINI_PROGRAM_V3_PREFLIGHT_SELECTOR;
+}
+function hasResetDeclaration(rule) {
+	let found = false;
+	rule.walkDecls((decl) => {
+		if (V3_PREFLIGHT_RESET_PROPS.has(decl.prop)) found = true;
+	});
+	return found;
+}
+function createPreflightDeclarations(cssPreflight) {
+	if (!cssPreflight || typeof cssPreflight !== "object") return [];
+	return Object.entries(cssPreflight).filter((entry) => entry[1] !== false).map(([prop, value]) => postcss.decl({
+		prop,
+		value: value.toString()
+	}));
+}
+function ensureMiniProgramV3PreflightReset(css, cssPreflight) {
+	const declarations = createPreflightDeclarations(cssPreflight);
+	if (declarations.length === 0) return css;
+	try {
+		const root = postcss.parse(css);
+		let targetRule;
+		let hasReset = false;
+		root.walkRules((rule) => {
+			if (!isMiniProgramV3PreflightRule(rule)) return;
+			targetRule ?? (targetRule = rule);
+			if (hasResetDeclaration(rule)) hasReset = true;
+		});
+		if (!targetRule || hasReset) return css;
+		targetRule.append(...declarations.map((decl) => decl.clone()));
+		return root.toString();
+	} catch {
+		return css;
+	}
+}
+async function transformTailwindV3CssToWeapp(css, options) {
+	return ensureMiniProgramV3PreflightReset(pruneMiniProgramGeneratedCss((await defaultStyleHandler(css, {
+		cssChildCombinatorReplaceValue: ["view", "text"],
+		cssRemoveHoverPseudoClass: true,
+		isMainChunk: true,
+		majorVersion: 3,
+		...options
+	})).css, { preservePreflight: true }), options?.cssPreflight);
+}
+async function transformTailwindV3CssByTarget(css, target, options) {
+	return target === "weapp" ? transformTailwindV3CssToWeapp(css, options) : css;
+}
+//#endregion
+//#region src/tailwindcss/v3-engine/generator.ts
+const runtimeReadyPromiseCache = /* @__PURE__ */ new Map();
+const incrementalGenerateCache = /* @__PURE__ */ new Map();
+function isLegacyContentObject(value) {
+	return typeof value === "object" && value !== null && "files" in value;
+}
+function createRawContentEntries(candidates, sources) {
+	const entries = [];
+	const candidateContent = [...candidates].join(" ");
+	if (candidateContent.length > 0) entries.push({
+		raw: candidateContent,
+		extension: "html"
+	});
+	for (const source of sources) entries.push({
+		raw: source.content,
+		extension: source.extension ?? "html"
+	});
+	return entries;
+}
+function createChangedContentEntries(candidates, sources) {
+	return createRawContentEntries(candidates, sources).map((entry) => ({
+		content: entry.raw,
+		extension: entry.extension
+	}));
+}
+function collectCandidates(candidates) {
+	return new Set(candidates ?? []);
+}
+function mergeContent(content, rawEntries) {
+	if (isLegacyContentObject(content)) return {
+		...content,
+		relative: content.relative ?? true,
+		files: [...[].concat(content.files ?? []), ...rawEntries]
+	};
+	return {
+		relative: true,
+		files: [...[].concat(content ?? []), ...rawEntries]
+	};
+}
+function normalizeConfigObject(config) {
+	if (!config || typeof config !== "object") return config;
+	const maybeDefault = config.default;
+	if (maybeDefault && typeof maybeDefault === "object") return maybeDefault;
+	return config;
+}
+function hasExplicitContentInput(options) {
+	return options.candidates !== void 0 || options.sources !== void 0;
+}
+function createExplicitContentConfig(rawEntries) {
+	return {
+		relative: true,
+		files: rawEntries
+	};
+}
+function createTailwindConfig(source, options) {
+	const config = { ...normalizeConfigObject(source.configObject) ?? {} };
+	const rawEntries = createRawContentEntries(options.candidates ?? [], options.sources ?? []);
+	config.content = hasExplicitContentInput(options) ? createExplicitContentConfig(rawEntries) : mergeContent(config.content, rawEntries);
+	return config;
+}
+function loadTailwindV3Internals(source) {
+	const requireFromProject = createRequire(`${source.cwd}/package.json`);
+	const requireFromRuntime = createRequire(import.meta.url);
+	const requireTailwind = (id) => {
+		try {
+			return requireFromProject(id);
+		} catch {
+			return requireFromRuntime(id);
+		}
+	};
+	const collapseAdjacentRulesModule = requireTailwind(`${source.packageName}/lib/lib/collapseAdjacentRules`);
+	const collapseDuplicateDeclarationsModule = requireTailwind(`${source.packageName}/lib/lib/collapseDuplicateDeclarations`);
+	const generateRulesModule = requireTailwind(`${source.packageName}/lib/lib/generateRules`);
+	const sharedStateModule = requireTailwind(`${source.packageName}/lib/lib/sharedState`);
+	const setupContextUtils = requireTailwind(`${source.packageName}/lib/lib/setupContextUtils`);
+	const processTailwindFeaturesModule = requireTailwind(`${source.packageName}/lib/processTailwindFeatures`);
+	const resolveDefaultsAtRulesModule = requireTailwind(`${source.packageName}/lib/lib/resolveDefaultsAtRules`);
+	const resolveConfigModule = requireTailwind(`${source.packageName}/lib/public/resolve-config`);
+	const validateConfigModule = requireTailwind(`${source.packageName}/lib/util/validateConfig.js`);
+	return {
+		collapseAdjacentRules: collapseAdjacentRulesModule["default"] ?? collapseAdjacentRulesModule,
+		collapseDuplicateDeclarations: collapseDuplicateDeclarationsModule["default"] ?? collapseDuplicateDeclarationsModule,
+		createContext: setupContextUtils["createContext"],
+		generateRules: generateRulesModule["generateRules"],
+		notOnDemandCandidate: String(sharedStateModule["NOT_ON_DEMAND"] ?? "*"),
+		processTailwindFeatures: processTailwindFeaturesModule["default"] ?? processTailwindFeaturesModule,
+		resolveDefaultsAtRules: resolveDefaultsAtRulesModule["default"] ?? resolveDefaultsAtRulesModule,
+		resolveConfig: resolveConfigModule["default"] ?? resolveConfigModule,
+		validateConfig: validateConfigModule["validateConfig"]
+	};
+}
+function createStableJson(value) {
+	if (value === void 0) return "undefined";
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => createStableJson(item)).join(",")}]`;
+	return `{${Object.keys(value).sort().map((key) => {
+		const record = value;
+		return `${JSON.stringify(key)}:${createStableJson(record[key])}`;
+	}).join(",")}}`;
+}
+function createDependencyFingerprint(files) {
+	return files.map((file) => {
+		try {
+			const stat = fs.statSync(file);
+			return `${file}:${stat.size}:${stat.mtimeMs}`;
+		} catch {
+			return `${file}:missing`;
+		}
+	}).join("|");
+}
+function createIncrementalGenerateCacheKey(source, target, styleOptions) {
+	return [
+		source.packageName,
+		source.postcssPlugin,
+		source.cwd,
+		source.config ?? "config:missing",
+		createDependencyFingerprint(source.dependencies),
+		source.css,
+		createStableJson(normalizeConfigObject(source.configObject)?.content),
+		target,
+		createStableJson(styleOptions)
+	].join("\0");
+}
+function createRuntimeReadyCacheKey(source, rootPath) {
+	return [
+		source.packageName,
+		source.postcssPlugin,
+		rootPath ?? "missing",
+		source.config ?? "config:missing",
+		source.cwd
+	].join("\0");
+}
+function isDirectUtilitiesOnlyCss(css) {
+	return css.replace(/\s+/g, "") === "@tailwindutilities;";
+}
+function collectClassSet(context) {
+	const classSet = /* @__PURE__ */ new Set();
+	for (const candidate of context.classCache.keys()) if (String(candidate) !== "*") classSet.add(candidate);
+	return classSet;
+}
+function collectDependencyMessages(result) {
+	const dependencies = /* @__PURE__ */ new Set();
+	for (const message of result.messages) {
+		const file = message["file"];
+		if (message["type"] === "dependency" && typeof file === "string") dependencies.add(file);
+	}
+	return dependencies;
+}
+function sortCandidates(candidates) {
+	return [...candidates].sort((a, z) => {
+		if (a === z) return 0;
+		return a < z ? -1 : 1;
+	});
+}
+function appendUtilityRules(root, context, rules) {
+	const sortedRules = context.offsets.sort(rules);
+	for (const [sort, rule] of sortedRules) {
+		const tailwindRaw = rule.raws.tailwind;
+		if (sort.layer === "utilities" || sort.layer === "variants" && tailwindRaw?.parentLayer === "utilities") root.append(rule.clone());
+	}
+}
+function appendDirectUtilityRules(root, context) {
+	appendUtilityRules(root, context, [...context.ruleCache]);
+}
+function createRuntimeReadyPromise(source) {
+	const patcher = createTailwindcssPatcher({
+		basedir: source.cwd,
+		supportCustomLengthUnitsPatch: true,
+		tailwindcss: {
+			...source.config === void 0 ? {} : { config: source.config },
+			cwd: source.cwd,
+			packageName: source.packageName,
+			postcssPlugin: source.postcssPlugin,
+			version: 3
+		}
+	});
+	const cacheKey = createRuntimeReadyCacheKey(source, patcher.packageInfo?.rootPath);
+	const cached = runtimeReadyPromiseCache.get(cacheKey);
+	if (cached) return cached;
+	const task = ensureTailwindcssRuntimePatch(patcher, { clearRequireCache: true }).catch((error) => {
+		runtimeReadyPromiseCache.delete(cacheKey);
+		throw error;
+	});
+	runtimeReadyPromiseCache.set(cacheKey, task);
+	return task;
+}
+function createTailwindV3Engine(source) {
+	const runtimeReadyPromise = createRuntimeReadyPromise(source);
+	let tailwindInternals;
+	async function generateOnce(generateSource, options = {}) {
+		await runtimeReadyPromise;
+		tailwindInternals ?? (tailwindInternals = loadTailwindV3Internals(source));
+		const internals = tailwindInternals;
+		const { styleOptions, target = "weapp" } = options;
+		const tailwindConfig = internals.validateConfig(internals.resolveConfig(createTailwindConfig(generateSource, options)));
+		const changedContent = createChangedContentEntries(options.candidates ?? [], options.sources ?? []);
+		const root = postcss.parse(generateSource.css, { from: void 0 });
+		const result = {
+			css: "",
+			messages: []
+		};
+		let context;
+		if (isDirectUtilitiesOnlyCss(generateSource.css)) {
+			context = internals.createContext(tailwindConfig, changedContent, root);
+			internals.generateRules(new Set(sortCandidates([internals.notOnDemandCandidate, ...collectCandidates(options.candidates)])), context);
+			root.removeAll();
+			appendDirectUtilityRules(root, context);
+			internals.resolveDefaultsAtRules(context)(root, result);
+			internals.collapseAdjacentRules(context)(root, result);
+			internals.collapseDuplicateDeclarations(context)(root, result);
+		} else {
+			const setupContext = () => {
+				return (currentRoot) => internals.createContext(tailwindConfig, changedContent, currentRoot);
+			};
+			context = await internals.processTailwindFeatures(setupContext)(root, result);
+		}
+		const rawCss = root.toString();
+		const css = await transformTailwindV3CssByTarget(rawCss, target, styleOptions);
+		const dependencies = collectDependencyMessages(result);
+		for (const dependency of generateSource.dependencies) dependencies.add(dependency);
+		const classSet = collectClassSet(context);
+		return {
+			css,
+			rawCss,
+			context,
+			classSet,
+			rawCandidates: collectCandidates(options.candidates),
+			dependencies: [...dependencies],
+			sources: [],
+			root: null,
+			target,
+			version: 3
+		};
+	}
+	async function generateIncrementalMissingUtilities(context, candidates, target, styleOptions) {
+		tailwindInternals ?? (tailwindInternals = loadTailwindV3Internals(source));
+		const internals = tailwindInternals;
+		const root = postcss.root();
+		const result = {
+			css: "",
+			messages: []
+		};
+		appendUtilityRules(root, context, internals.generateRules(new Set(sortCandidates(candidates)), context));
+		internals.resolveDefaultsAtRules(context)(root, result);
+		internals.collapseAdjacentRules(context)(root, result);
+		internals.collapseDuplicateDeclarations(context)(root, result);
+		const rawCss = root.toString();
+		return {
+			css: await transformTailwindV3CssByTarget(rawCss, target, styleOptions),
+			rawCss,
+			classSet: collectClassSet(context),
+			dependencies: collectDependencyMessages(result)
+		};
+	}
+	async function generateWithIncrementalCache(options = {}) {
+		if ((options.sources?.length ?? 0) > 0) return generateOnce(source, options);
+		const target = options.target ?? "weapp";
+		const requestedCandidates = collectCandidates(options.candidates);
+		if (requestedCandidates.size === 0) return generateOnce(source, options);
+		const cacheKey = createIncrementalGenerateCacheKey(source, target, options.styleOptions);
+		const cached = incrementalGenerateCache.get(cacheKey);
+		if (cached) {
+			const missingCandidates = [...requestedCandidates].filter((candidate) => !cached.seenCandidates.has(candidate));
+			if (missingCandidates.length === 0) return {
+				css: cached.css,
+				rawCss: cached.rawCss,
+				incrementalCss: "",
+				incrementalRawCss: "",
+				classSet: new Set(cached.classSet),
+				rawCandidates: new Set(cached.seenCandidates),
+				dependencies: cached.dependencies,
+				sources: [],
+				root: null,
+				target: cached.target,
+				version: 3
+			};
+			const generated = await generateIncrementalMissingUtilities(cached.context, missingCandidates, target, options.styleOptions);
+			for (const candidate of missingCandidates) cached.seenCandidates.add(candidate);
+			for (const className of generated.classSet) cached.classSet.add(className);
+			cached.css = [cached.css, generated.css].filter(Boolean).join("\n");
+			cached.rawCss = [cached.rawCss, generated.rawCss].filter(Boolean).join("\n");
+			cached.dependencies = [...new Set([...cached.dependencies, ...generated.dependencies])];
+			return {
+				css: cached.css,
+				rawCss: cached.rawCss,
+				incrementalCss: generated.css,
+				incrementalRawCss: generated.rawCss,
+				classSet: new Set(cached.classSet),
+				rawCandidates: new Set(cached.seenCandidates),
+				dependencies: cached.dependencies,
+				sources: [],
+				root: null,
+				target: cached.target,
+				version: 3
+			};
+		}
+		const generated = await generateOnce(source, options);
+		incrementalGenerateCache.set(cacheKey, {
+			context: generated.context,
+			seenCandidates: new Set(requestedCandidates),
+			classSet: new Set(generated.classSet),
+			css: generated.css,
+			rawCss: generated.rawCss,
+			dependencies: generated.dependencies,
+			target: generated.target
+		});
+		return generated;
+	}
+	async function generate(options = {}) {
+		return options.incrementalCache ? generateWithIncrementalCache(options) : generateOnce(source, options);
+	}
+	return {
+		source,
+		async validateCandidates(candidates) {
+			return (await generate({
+				candidates,
+				incrementalCache: true,
+				target: "tailwind"
+			})).classSet;
+		},
+		generate
+	};
+}
+//#endregion
+//#region src/tailwindcss/v3-engine/source.ts
+const DEFAULT_TAILWIND_V3_CSS = [
+	"@tailwind base;",
+	"@tailwind components;",
+	"@tailwind utilities;"
+].join("\n");
+function parseConfigParam(params) {
+	const value = params.trim();
+	return /^(['"])(.+)\1$/.exec(value)?.[2];
+}
+function resolveOptionalPath(value, base) {
+	if (!value) return;
+	return path.isAbsolute(value) ? value : path.resolve(base, value);
+}
+function resolveCssConfig(css, base) {
+	if (!css) return {
+		css,
+		config: void 0
+	};
+	const root = postcss.parse(css);
+	let config;
+	root.walkAtRules("config", (rule) => {
+		const configPath = parseConfigParam(rule.params);
+		if (!configPath) return;
+		if (!config) config = resolveOptionalPath(configPath, base);
+		rule.remove();
+	});
+	return {
+		config,
+		css: root.toString()
+	};
+}
+function getProjectRoot(patcher) {
+	return patcher.options?.projectRoot ?? process.cwd();
+}
+function normalizeLoadedConfig(config) {
+	if (!config || typeof config !== "object") return config;
+	const maybeDefault = config.default;
+	if (maybeDefault && typeof maybeDefault === "object") return maybeDefault;
+	return config;
+}
+function resolveTailwindCssPackageName(patcher) {
+	return resolveTailwindcssOptions(patcher.options)?.packageName ?? patcher.packageInfo?.name ?? "tailwindcss";
+}
+async function resolveTailwindV3Source(options = {}) {
+	const projectRoot = options.projectRoot ?? process.cwd();
+	const base = options.base ?? options.cwd ?? projectRoot;
+	const cssConfig = resolveCssConfig(options.css, base);
+	const config = resolveOptionalPath(options.config, base) ?? cssConfig.config;
+	const cwd = options.cwd ?? (config ? path.dirname(config) : projectRoot);
+	const loaded = await loadConfig(omitUndefined({
+		config,
+		cwd
+	}));
+	return {
+		version: 3,
+		projectRoot,
+		cwd,
+		base,
+		css: cssConfig.css ?? options.css ?? DEFAULT_TAILWIND_V3_CSS,
+		config: loaded?.filepath ?? config,
+		configObject: normalizeLoadedConfig(loaded?.config),
+		dependencies: loaded?.filepath ? [loaded.filepath] : [],
+		packageName: options.packageName ?? "tailwindcss",
+		postcssPlugin: options.postcssPlugin ?? options.packageName ?? "tailwindcss"
+	};
+}
+function resolveTailwindV3SourceOptionsFromPatcher(patcher) {
+	const projectRoot = getProjectRoot(patcher);
+	const tailwindOptions = resolveTailwindcssOptions(patcher.options);
+	return {
+		projectRoot,
+		cwd: tailwindOptions?.v3?.cwd ?? tailwindOptions?.cwd ?? projectRoot,
+		config: tailwindOptions?.v3?.config ?? tailwindOptions?.config,
+		packageName: resolveTailwindCssPackageName(patcher),
+		postcssPlugin: tailwindOptions?.v3?.postcssPlugin ?? tailwindOptions?.postcssPlugin
+	};
+}
+function resolveTailwindV3SourceFromPatcher(patcher) {
+	return resolveTailwindV3Source(resolveTailwindV3SourceOptionsFromPatcher(patcher));
+}
+//#endregion
+export { createSourceScanPattern as A, omitUndefined as B, createTailwindV4Engine$1 as C, filterUnsupportedMiniProgramTailwindV4Candidates as D, removeUnsupportedCascadeLayers as E, createDebug as F, findWorkspacePackageDir as H, createTailwindcssPatcher as I, readInstalledPackageMajorVersion as L, normalizeLegacyContentEntries as M, parseConfigParam$1 as N, loadTailwindV4DesignSystem as O, resolveCssSourceEntries as P, findTailwindConfig as R, resolveTailwindV4SourceOptionsFromPatcher as S, transformTailwindV4CssToWeapp as T, findWorkspaceRoot as U, findNearestPackageRoot as V, resolveViteSourceScanEntries as _, transformTailwindV3CssByTarget as a, resolveTailwindV4SourceFromPatchOptions as b, getRuntimeClassSetCacheEntry as c, invalidateRuntimeClassSet as d, runtimeSignaturePatchersSymbol as f, resolveTailwindV4EntriesFromCssCached as g, resolveTailwindV4EntriesFromCss as h, createTailwindV3Engine as i, expandTailwindSourceEntries as j, collectCssInlineSourceCandidates as k, getRuntimeClassSetSignature as l, discoverTailwindV4CssEntries as m, resolveTailwindV3SourceFromPatcher as n, transformTailwindV3CssToWeapp as o, createViteSourceScanMatcher as p, resolveTailwindV3SourceOptionsFromPatcher as r, ensureTailwindcssRuntimePatch as s, resolveTailwindV3Source as t, getRuntimeClassSetSignatureWithSources as u, resolveViteTailwindV4CssDependencies as v, transformTailwindV4CssByTarget as w, resolveTailwindV4SourceFromPatcher as x, resolveTailwindV4Source$1 as y, resolveTailwindcssOptions as z };