weapp-tailwindcss 5.0.0-next.2 → 5.0.0-next.21

package/dist/v3-engine-CCwvhRrQ.js

@@ -0,0 +1,3473 @@
+const require_chunk = require("./chunk-8l464Juk.js");
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs);
+let node_module = require("node:module");
+let postcss = require("postcss");
+postcss = require_chunk.__toESM(postcss);
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
+let _weapp_tailwindcss_shared = require("@weapp-tailwindcss/shared");
+let tailwindcss_patch = require("tailwindcss-patch");
+let node_url = require("node:url");
+let debug = require("debug");
+debug = require_chunk.__toESM(debug);
+let node_fs_promises = require("node:fs/promises");
+let fast_glob = require("fast-glob");
+fast_glob = require_chunk.__toESM(fast_glob);
+let tailwindcss_config = require("tailwindcss-config");
+let micromatch = require("micromatch");
+micromatch = require_chunk.__toESM(micromatch);
+let _weapp_tailwindcss_postcss = require("@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 = node_path.default.resolve(startDir);
+	while (true) {
+		if ((0, node_fs.existsSync)(node_path.default.join(current, "pnpm-workspace.yaml"))) return current;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findNearestPackageRoot(startDir) {
+	if (!startDir) return;
+	let current = node_path.default.resolve(startDir);
+	while (true) {
+		if ((0, node_fs.existsSync)(node_path.default.join(current, "package.json"))) return current;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function findWorkspacePackageDir(rootDir, packageName) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [node_path.default.resolve(rootDir)];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		const normalized = node_path.default.normalize(current);
+		if (visited.has(normalized)) continue;
+		visited.add(normalized);
+		try {
+			const pkgPath = node_path.default.join(normalized, "package.json");
+			if ((0, node_fs.existsSync)(pkgPath)) {
+				if (JSON.parse((0, node_fs.readFileSync)(pkgPath, "utf8"))?.name === packageName) return normalized;
+			}
+		} catch {}
+		let entries;
+		try {
+			entries = (0, node_fs.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(node_path.default.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 (node_path.default.isAbsolute(specifier)) return true;
+	return GENERIC_RELATIVE_SPECIFIERS.some((prefix) => specifier.startsWith(`${prefix}/`) || specifier.startsWith(`${prefix}\\`));
+}
+function resolveModuleFromPaths(specifier, paths) {
+	if (!specifier || isPathSpecifier(specifier) || paths.length === 0) return;
+	try {
+		return (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href).resolve(specifier, { paths });
+	} catch {
+		return;
+	}
+}
+function resolveTailwindConfigFallback(packageName, paths) {
+	if (!packageName) return;
+	for (const suffix of DEFAULT_TAILWIND_CONFIG_SPECIFIERS) {
+		const resolved = resolveModuleFromPaths(`${packageName}/${suffix}`, paths);
+		if (resolved) return resolved;
+	}
+}
+function appendNodeModules(paths, dir) {
+	if (!dir) return;
+	const nodeModulesDir = node_path.default.join(dir, "node_modules");
+	if ((0, node_fs.existsSync)(nodeModulesDir)) paths.add(nodeModulesDir);
+}
+function findTailwindConfig(searchRoots) {
+	for (const root of searchRoots) for (const file of TAILWIND_CONFIG_FILES) {
+		const candidate = node_path.default.resolve(root, file);
+		if ((0, node_fs.existsSync)(candidate)) return candidate;
+	}
+}
+function createDefaultResolvePaths(basedir) {
+	const paths = /* @__PURE__ */ new Set();
+	let fallbackCandidates = [];
+	if (basedir) {
+		const resolvedBase = node_path.default.resolve(basedir);
+		appendNodeModules(paths, resolvedBase);
+		fallbackCandidates.push(resolvedBase);
+		const packageRoot = findNearestPackageRoot(resolvedBase);
+		if (packageRoot) {
+			appendNodeModules(paths, packageRoot);
+			fallbackCandidates.push(packageRoot);
+		}
+	}
+	const cwd = node_process.default.cwd();
+	appendNodeModules(paths, cwd);
+	try {
+		const modulePath = (0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+		const candidate = (0, node_fs.existsSync)(modulePath) && !node_path.default.extname(modulePath) ? modulePath : node_path.default.dirname(modulePath);
+		paths.add(candidate);
+	} catch {
+		paths.add(require("url").pathToFileURL(__filename).href);
+	}
+	if (paths.size === 0) {
+		fallbackCandidates = fallbackCandidates.filter(Boolean);
+		if (fallbackCandidates.length === 0) fallbackCandidates.push(cwd);
+		for (const candidate of fallbackCandidates) paths.add(candidate);
+	}
+	return [...paths];
+}
+//#endregion
+//#region src/tailwindcss/version.ts
+function normalizeSupportedTailwindcssMajorVersion(version) {
+	return version === 3 || version === 4 ? version : void 0;
+}
+function readPackageJson(packageJsonPath) {
+	try {
+		return JSON.parse((0, node_fs.readFileSync)(packageJsonPath, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findPackageJsonDeclaringPackage(packageName, base) {
+	let current = node_path.default.resolve(base);
+	while (true) {
+		const pkgPath = node_path.default.join(current, "package.json");
+		if ((0, node_fs.existsSync)(pkgPath)) {
+			const pkg = readPackageJson(pkgPath);
+			if (readDeclaredPackageVersion(packageName, pkg)) return pkgPath;
+			if (pkg?.name !== "weapp-tailwindcss") return;
+		}
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function readDeclaredPackageVersion(packageName, pkg) {
+	return pkg?.dependencies?.[packageName] ?? pkg?.devDependencies?.[packageName] ?? pkg?.peerDependencies?.[packageName] ?? pkg?.optionalDependencies?.[packageName];
+}
+function readDeclaredPackageMajorVersion(version) {
+	const match = version?.match(/(?:^|\D)([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 = (0, node_module.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 ? node_path.default.resolve(basedir) : void 0;
+	const cacheRoot = findNearestPackageRoot(normalizedBasedir) ?? normalizedBasedir ?? node_process.default.cwd();
+	if (cacheDir) if (node_path.default.isAbsolute(cacheDir)) cache.dir = cacheDir;
+	else if (normalizedBasedir) cache.dir = node_path.default.resolve(normalizedBasedir, cacheDir);
+	else cache.dir = node_path.default.resolve(node_process.default.cwd(), cacheDir);
+	else cache.dir = node_path.default.join(cacheRoot, "node_modules", ".cache", "tailwindcss-patch");
+	if (normalizedBasedir) cache.cwd = normalizedBasedir;
+	const resolvePaths = createDefaultResolvePaths(cache.cwd ?? normalizedBasedir ?? node_process.default.cwd());
+	const normalizedUserOptions = normalizeTailwindcssPatcherOptions(tailwindcssPatcherOptions);
+	const extendLengthUnits = normalizeExtendLengthUnits(supportCustomLengthUnitsPatch ?? true);
+	const baseTailwindOptions = (0, _weapp_tailwindcss_shared.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 = (0, _weapp_tailwindcss_shared.defuOverrideArray)(normalizedUserOptions ?? {}, baseOptions);
+	const resolvedTailwindOptions = resolvedOptions.tailwindcss;
+	if (resolvedTailwindOptions) {
+		const existingResolve = resolvedTailwindOptions.resolve ?? {};
+		const sourcePaths = Array.isArray(existingResolve.paths) && existingResolve.paths.length > 0 ? existingResolve.paths : resolvePaths;
+		resolvedTailwindOptions.resolve = {
+			...existingResolve,
+			paths: [...new Set(sourcePaths)]
+		};
+		_weapp_tailwindcss_logger.logger.debug("Tailwind resolve config %O", {
+			packageName: resolvedTailwindOptions.packageName,
+			version: resolvedTailwindOptions.version,
+			resolve: resolvedTailwindOptions.resolve,
+			cwd: resolvedTailwindOptions.cwd
+		});
+		if (typeof resolvedTailwindOptions.postcssPlugin === "string") {
+			const resolvedPlugin = resolveModuleFromPaths(resolvedTailwindOptions.postcssPlugin, resolvedTailwindOptions.resolve?.paths ?? resolvePaths);
+			if (resolvedPlugin) resolvedTailwindOptions.postcssPlugin = resolvedPlugin;
+		}
+		const searchRoots = /* @__PURE__ */ new Set();
+		if (resolvedTailwindOptions.cwd) searchRoots.add(resolvedTailwindOptions.cwd);
+		for (const resolvePath of resolvedTailwindOptions.resolve?.paths ?? []) {
+			const parentDir = node_path.default.dirname(resolvePath);
+			searchRoots.add(parentDir);
+		}
+		const configPath = findTailwindConfig(searchRoots);
+		if (!resolvedTailwindOptions.config) if (configPath) resolvedTailwindOptions.config = configPath;
+		else {
+			const fallbackConfig = resolveTailwindConfigFallback(resolvedTailwindOptions.packageName, resolvedTailwindOptions.resolve.paths ?? resolvePaths);
+			if (fallbackConfig) resolvedTailwindOptions.config = fallbackConfig;
+		}
+		if (!resolvedTailwindOptions.cwd && configPath) resolvedTailwindOptions.cwd = node_path.default.dirname(configPath);
+		resolvedOptions.tailwindcss = resolvedTailwindOptions;
+	}
+	try {
+		return new tailwindcss_patch.TailwindcssPatcher(resolvedOptions);
+	} catch (error) {
+		const searchPaths = resolvedOptions.tailwindcss?.resolve?.paths;
+		if (error instanceof Error && TAILWINDCSS_NOT_FOUND_RE.test(error.message)) {
+			if (!hasLoggedMissingTailwind) {
+				_weapp_tailwindcss_logger.logger.warn("Tailwind CSS 未安装，已跳过 Tailwind 运行时能力。若需使用 Tailwind 能力，请安装 tailwindcss。");
+				hasLoggedMissingTailwind = true;
+			}
+			return createFallbackTailwindcssPatcher();
+		}
+		if (error instanceof Error && UNABLE_TO_LOCATE_TAILWINDCSS_RE.test(error.message)) _weapp_tailwindcss_logger.logger.error("无法定位 Tailwind CSS 包 \"%s\"，已尝试路径: %O", resolvedOptions.tailwindcss?.packageName, searchPaths);
+		throw error;
+	}
+}
+//#endregion
+//#region src/debug/index.ts
+const _debug = (0, debug.default)("weapp-tw");
+function createDebug(prefix) {
+	const debug$2 = ((formatter, ...args) => {
+		return _debug((prefix ?? "") + formatter, ...args);
+	});
+	Object.defineProperty(debug$2, "enabled", {
+		enumerable: false,
+		configurable: false,
+		get() {
+			return _debug.enabled;
+		}
+	});
+	return debug$2;
+}
+//#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"
+];
+const FULL_SOURCE_SCAN_EXTENSIONS = [
+	"js",
+	"jsx",
+	"mjs",
+	"cjs",
+	"ts",
+	"tsx",
+	"mts",
+	"cts",
+	"vue",
+	"uvue",
+	"nvue",
+	"svelte",
+	"mpx",
+	"html",
+	"wxml",
+	"axml",
+	"jxml",
+	"ksml",
+	"ttml",
+	"qml",
+	"tyml",
+	"xhsml",
+	"swan",
+	"css",
+	"wxss",
+	"acss",
+	"jxss",
+	"ttss",
+	"qss",
+	"tyss",
+	"scss",
+	"sass",
+	"less",
+	"styl",
+	"stylus"
+];
+function createSourceScanPattern(extensions = DEFAULT_SOURCE_SCAN_EXTENSIONS) {
+	return `**/*.{${extensions.join(",")}}`;
+}
+const FULL_SOURCE_SCAN_PATTERN = createSourceScanPattern(FULL_SOURCE_SCAN_EXTENSIONS);
+const FULL_SOURCE_SCAN_EXTENSION_RE = new RegExp(`\\.(?:${FULL_SOURCE_SCAN_EXTENSIONS.map((extension) => extension.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})$`);
+function toPosixPath(value) {
+	return value.split(node_path.default.sep).join("/");
+}
+function resolveSourceScanPath(value) {
+	const resolved = node_path.default.resolve(value);
+	try {
+		return node_fs.realpathSync.native(resolved);
+	} catch {
+		return resolved;
+	}
+}
+function normalizeEntryPattern(entry) {
+	return node_path.default.isAbsolute(entry.pattern) ? toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), entry.pattern)) : entry.pattern;
+}
+function isFileMatchedByTailwindSourceEntry(file, entry) {
+	const relative = toPosixPath(node_path.default.relative(resolveSourceScanPath(entry.base), file));
+	return relative && !relative.startsWith("../") && !node_path.default.isAbsolute(relative) && micromatch.default.isMatch(relative, normalizeEntryPattern(entry));
+}
+function isFileExcludedByTailwindSourceEntries(file, entries) {
+	if (!entries?.length) return false;
+	const resolvedFile = resolveSourceScanPath(file);
+	return entries.some((entry) => entry.negated && isFileMatchedByTailwindSourceEntry(resolvedFile, entry));
+}
+function isFileMatchedByTailwindSourceEntries(file, entries) {
+	if (!entries?.length) return true;
+	const positiveEntries = entries.filter((entry) => !entry.negated);
+	const negativeEntries = entries.filter((entry) => entry.negated);
+	if (positiveEntries.length === 0) return false;
+	const resolvedFile = resolveSourceScanPath(file);
+	if (!positiveEntries.some((entry) => isFileMatchedByTailwindSourceEntry(resolvedFile, entry))) return false;
+	return !negativeEntries.some((entry) => isFileMatchedByTailwindSourceEntry(resolvedFile, entry));
+}
+function createTailwindSourceEntryMatcher(entries) {
+	if (!entries?.length) return;
+	return (file) => isFileMatchedByTailwindSourceEntries(file, entries);
+}
+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 node_path.default.dirname(source.file);
+	return fallbackBase;
+}
+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, options = {}) {
+	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) {
+			const part = input.slice(lastPos, index);
+			if (part || options.keepEmpty) parts.push(part);
+			lastPos = index + 1;
+		}
+	}
+	const part = input.slice(lastPos);
+	if (part || options.keepEmpty) parts.push(part);
+	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, ",", { keepEmpty: true })).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 (0, node_fs_promises.stat)(file)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindSourceEntry(sourcePath, base, negated, defaultPattern = createSourceScanPattern()) {
+	const absoluteSource = node_path.default.isAbsolute(sourcePath) ? node_path.default.resolve(sourcePath) : node_path.default.resolve(base, sourcePath);
+	if (await pathExistsAsDirectory(absoluteSource)) return {
+		base: absoluteSource,
+		negated,
+		pattern: normalizeGlobPattern(defaultPattern)
+	};
+	if (node_path.default.isAbsolute(sourcePath)) return {
+		base: node_path.default.dirname(absoluteSource),
+		negated,
+		pattern: normalizeGlobPattern(node_path.default.basename(absoluteSource))
+	};
+	const { prefix, rest } = splitStaticGlobPrefix(sourcePath);
+	if (prefix.length > 0 && rest.length > 0) return {
+		base: node_path.default.resolve(base, ...prefix),
+		negated,
+		pattern: normalizeGlobPattern(rest.join("/"))
+	};
+	return {
+		base,
+		negated,
+		pattern: normalizeGlobPattern(sourcePath)
+	};
+}
+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,
+		sourcePath: match[2]
+	} : void 0;
+}
+async function resolveCssSourceEntries(root, base, defaultPattern = createSourceScanPattern()) {
+	const entries = [];
+	const tasks = [];
+	root.walkAtRules("source", (rule) => {
+		const parsed = parseSourceFileParam(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 = {}) {
+	if (entries.length === 0) return [];
+	const files = /* @__PURE__ */ new Set();
+	const entriesByBase = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const base = node_path.default.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 ignoredSources = options.ignore?.map((pattern) => ({
+			base,
+			pattern: normalizeGlobPattern(pattern),
+			negated: true
+		}));
+		const matched = await (0, tailwindcss_patch.resolveProjectSourceFiles)({
+			cwd: base,
+			sources: group,
+			...ignoredSources === void 0 ? {} : { ignoredSources }
+		});
+		for (const file of matched) files.add(node_path.default.resolve(file));
+	}));
+	return [...files].filter((file) => !isFileExcludedByTailwindSourceEntries(file, entries));
+}
+//#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/v4-engine/miniprogram.ts
+const defaultStyleHandler$1 = (0, _weapp_tailwindcss_postcss.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 = (0, _weapp_tailwindcss_postcss.protectDynamicColorMixAlpha)(normalizeTailwindV4GeneratedUrlValues(css), { customPropertyValues: options && "customPropertyValues" in options ? options.customPropertyValues : void 0 });
+	const result = await defaultStyleHandler$1(protectedCss.css, {
+		cssChildCombinatorReplaceValue: ["view", "text"],
+		cssRemoveHoverPseudoClass: true,
+		isMainChunk: true,
+		majorVersion: 4,
+		...options
+	});
+	return (0, _weapp_tailwindcss_postcss.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 = node_fs.default.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 = (0, tailwindcss_patch.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 createIncrementalStyleOptions(styleOptions) {
+	return {
+		...styleOptions,
+		isMainChunk: false
+	};
+}
+function collectCustomPropertyValues(css) {
+	const values = /* @__PURE__ */ new Map();
+	try {
+		postcss.default.parse(css).walkDecls((decl) => {
+			if (decl.prop.startsWith("--")) values.set(decl.prop, decl.value.trim());
+		});
+	} catch {}
+	return values;
+}
+function mergeCustomPropertyValues(target, css) {
+	for (const [prop, value] of collectCustomPropertyValues(css)) target.set(prop, value);
+}
+function seedIncrementalGenerateCache(options) {
+	const cacheKey = createIncrementalGenerateCacheKey$1(options.compatibleSource, options.target, options.styleOptions, options.tailwindcssV3Compatibility);
+	const customPropertyValues = collectCustomPropertyValues(options.compatibleSource.css);
+	mergeCustomPropertyValues(customPropertyValues, options.generated.css);
+	incrementalGenerateCache$1.set(cacheKey, {
+		seenCandidates: collectSeenCandidates(options.generated, options.requestedCandidates),
+		classSet: new Set(options.generated.classSet),
+		css: options.generated.css,
+		rawCss: options.generated.rawCss,
+		customPropertyValues,
+		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.default.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 resolveSourceBase$1(base, sourcePath) {
+	return node_path.default.isAbsolute(sourcePath) ? sourcePath : node_path.default.resolve(base, sourcePath);
+}
+async function resolveCssDefinedScanSources(source) {
+	let importSourceBase;
+	let hasSourceNone = false;
+	const from = source.dependencies[0];
+	let root;
+	try {
+		root = postcss.default.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);
+		}
+	});
+	const sourcePatterns = await resolveCssSourceEntries(root, source.base, "**/*");
+	if (!importSourceBase) {
+		if (sourcePatterns.length > 0) return sourcePatterns;
+		if (hasSourceNone) return false;
+		return;
+	}
+	return [await resolveTailwindSourceEntry(".", importSourceBase, false, "**/*"), ...sourcePatterns];
+}
+async function resolveScanSources(source, scanSources) {
+	if (scanSources !== true) return scanSources;
+	return await resolveCssDefinedScanSources(source) ?? false;
+}
+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.default.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(source) {
+	async function generateOnce(generateSource, options = {}) {
+		const { scanSources = true, styleOptions, tailwindcssV3Compatibility, target = "weapp", ...patchOptions } = options;
+		const engine = (0, tailwindcss_patch.createTailwindV4Engine)(createCompatibleSource(generateSource, target, tailwindcssV3Compatibility));
+		const resolvedScanSources = await resolveScanSources(generateSource, scanSources);
+		const filesystemCandidates = Array.isArray(resolvedScanSources) ? new Set(await (0, tailwindcss_patch.extractRawCandidates)(resolvedScanSources)) : void 0;
+		const resolvedCandidates = resolveTargetCandidates(new Set([...collectCandidates$1(patchOptions.candidates), ...filesystemCandidates ?? []]), target);
+		const result = await engine.generate(omitUndefined({
+			scanSources: false,
+			...patchOptions,
+			candidates: resolvedCandidates
+		}));
+		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, {
+					...createIncrementalStyleOptions(options.styleOptions),
+					customPropertyValues: cached.customPropertyValues
+				}) : "";
+				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");
+				mergeCustomPropertyValues(cached.customPropertyValues, incrementalCss);
+				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: (0, tailwindcss_patch.createTailwindV4Engine)(source).loadDesignSystem,
+		validateCandidates: (0, tailwindcss_patch.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 ?? node_process.default.cwd();
+}
+function resolveBase(value, fallback) {
+	return value === void 0 ? fallback : node_path.default.isAbsolute(value) ? node_path.default.resolve(value) : node_path.default.resolve(fallback, value);
+}
+function resolveConfigDir(config, projectRoot) {
+	if (!config) return;
+	const configPath = node_path.default.isAbsolute(config) ? config : node_path.default.resolve(projectRoot, config);
+	return node_path.default.dirname(configPath);
+}
+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.default.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 isRawTailwindcssPatchOptions(options) {
+	return Boolean(options && "tailwindcss" in options);
+}
+function resolvePatchTailwindV4SourceOptions(patcher) {
+	if (patcher.options) {
+		const projectRoot = getProjectRoot$1(patcher);
+		const tailwindOptions = resolveTailwindcssOptions(patcher.options);
+		const tailwindV4Options = readTailwindV4Options(patcher);
+		const cwd = resolveBase(tailwindOptions?.cwd, projectRoot);
+		const configuredBase = tailwindV4Options?.configuredBase ?? (isRawTailwindcssPatchOptions(patcher.options) ? tailwindV4Options?.base : void 0);
+		const baseFallbacks = uniqueDefined([
+			configuredBase,
+			cwd,
+			projectRoot,
+			resolveConfigDir(tailwindOptions?.config, projectRoot)
+		]);
+		return {
+			projectRoot,
+			cwd,
+			...configuredBase === void 0 ? {} : { base: configuredBase },
+			baseFallbacks,
+			...tailwindV4Options?.css === void 0 ? {} : { css: tailwindV4Options.css },
+			...tailwindV4Options?.cssSources === void 0 ? {} : { cssSources: tailwindV4Options.cssSources },
+			...tailwindV4Options?.cssEntries === void 0 ? {} : { cssEntries: tailwindV4Options.cssEntries },
+			packageName: resolveTailwindCssImportTarget(patcher)
+		};
+	}
+	return {
+		projectRoot: getProjectRoot$1(patcher),
+		packageName: resolveTailwindCssImportTarget(patcher)
+	};
+}
+function resolveTailwindV4SourceOptionsFromPatcher(patcher) {
+	const tailwindV4Options = readTailwindV4Options(patcher);
+	return omitUndefined({
+		...resolvePatchTailwindV4SourceOptions(patcher),
+		sources: tailwindV4Options?.sources
+	});
+}
+function resolveTailwindV4Source(options) {
+	return (0, tailwindcss_patch.resolveTailwindV4Source)(options?.css === void 0 ? options : {
+		...options,
+		css: normalizeTailwindV4CssPackageImports(options.css, options.packageName)
+	});
+}
+async function resolveTailwindV4SourceFromPatcher(patcher) {
+	return resolveTailwindV4Source(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 = (0, node_fs.readFileSync)(configPath, "utf8");
+	} catch {
+		return;
+	}
+	const contentProperty = findContentPropertyValue(source);
+	if (!contentProperty) return;
+	return parseStaticContentValue(source, contentProperty.start)?.value;
+}
+//#endregion
+//#region src/bundlers/vite/source-scan.ts
+const VITE_SOURCE_CANDIDATE_PATTERN = FULL_SOURCE_SCAN_PATTERN;
+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 node_path.default.isAbsolute(sourcePath) ? sourcePath : node_path.default.resolve(base, sourcePath);
+}
+function resolveConfigPath(base, configPath) {
+	if (node_path.default.isAbsolute(configPath)) return node_path.default.resolve(configPath);
+	let current = node_path.default.resolve(base);
+	while (true) {
+		const candidate = node_path.default.resolve(current, configPath);
+		if ((0, node_fs.existsSync)(candidate)) return candidate;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return node_path.default.resolve(base, configPath);
+}
+function createCssEntriesCacheKey(css, base, dependencies) {
+	return JSON.stringify({
+		base: node_path.default.resolve(base),
+		css,
+		dependencies
+	});
+}
+function addSourceScanDependency(dependencies, file) {
+	if (typeof file === "string" && file.length > 0) dependencies.add(node_path.default.resolve(file));
+}
+function addSourceScanDependencies(dependencies, files) {
+	for (const file of files ?? []) addSourceScanDependency(dependencies, file);
+}
+function createResolvedViteSourceScan(input, dependencies) {
+	return {
+		...input,
+		...dependencies.size > 0 ? { dependencies: [...dependencies].sort() } : {}
+	};
+}
+async function statConfigDependency(file) {
+	try {
+		const stats = await (0, node_fs_promises.stat)(file);
+		return {
+			file,
+			mtimeMs: stats.mtimeMs,
+			size: stats.size
+		};
+	} catch {
+		return {
+			file,
+			mtimeMs: -1,
+			size: -1
+		};
+	}
+}
+async function collectConfigDependencySignatures(root, base) {
+	const configPaths = /* @__PURE__ */ new Set();
+	root.walkAtRules("config", (rule) => {
+		const configPath = 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, node_path.default.dirname(configPath)));
+			continue;
+		}
+		try {
+			const loaded = await (0, tailwindcss_config.loadConfig)({
+				config: configPath,
+				cwd: node_path.default.dirname(configPath)
+			});
+			entries.push(...normalizeLegacyContentEntries(loaded?.config.content, node_path.default.dirname(configPath)));
+		} catch {}
+	}
+	return {
+		dependencies: [...configPaths],
+		entries
+	};
+}
+async function resolveTailwindV4EntriesFromCss(css, base) {
+	let root;
+	try {
+		root = postcss.default.parse(css);
+	} catch {
+		return;
+	}
+	let importSourceBase;
+	let hasSourceNone = false;
+	let hasTailwindCssImport = false;
+	const [sourceEntries, configEntries] = await Promise.all([resolveCssSourceEntries(root, base, VITE_SOURCE_CANDIDATE_PATTERN), resolveConfigContentEntries(root, base)]);
+	const entries = [...configEntries.entries, ...sourceEntries];
+	const inlineCandidates = collectCssInlineSourceCandidates(root);
+	root.walkAtRules("import", (rule) => {
+		if (!isTailwindCssImport(rule.params)) return;
+		hasTailwindCssImport = true;
+		const sourceParam = parseImportSourceParam(rule.params);
+		if (sourceParam?.none) hasSourceNone = true;
+		if (sourceParam?.sourcePath) importSourceBase = resolveSourceBase(base, sourceParam.sourcePath);
+	});
+	if (importSourceBase) return {
+		entries: [{
+			base: importSourceBase,
+			negated: false,
+			pattern: VITE_SOURCE_CANDIDATE_PATTERN
+		}, ...entries],
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	if (hasSourceNone) return {
+		entries,
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	if (entries.length > 0) return {
+		entries,
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	if (inlineCandidates.included.size > 0 || inlineCandidates.excluded.size > 0) return {
+		entries: [],
+		explicit: true,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	};
+	return hasTailwindCssImport ? {
+		entries: [],
+		explicit: false,
+		inlineCandidates,
+		dependencies: configEntries.dependencies
+	} : void 0;
+}
+async function resolveViteTailwindV4CssDependencies(css, base) {
+	return (await resolveTailwindV4EntriesFromCss(css, base))?.dependencies ?? [];
+}
+function collectExistingCssEntries(options) {
+	return [
+		...options.cssEntries ?? [],
+		...options.tailwindcss?.v4?.cssEntries ?? [],
+		...options.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssEntries ?? []
+	].filter((item) => typeof item === "string" && item.length > 0).map((item) => node_path.default.resolve(item)).filter((item) => (0, node_fs.existsSync)(item));
+}
+async function pathExistsAsFile(file) {
+	try {
+		return (await (0, node_fs_promises.stat)(file)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function resolveTailwindV4EntriesFromCssCached(css, base) {
+	let root;
+	try {
+		root = postcss.default.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 = node_path.default.resolve(root);
+	const ignore = ["**/node_modules/**", "**/.git/**"];
+	const resolvedOutDir = outDir ? node_path.default.resolve(resolvedRoot, outDir) : void 0;
+	if (resolvedOutDir) {
+		const relativeOutDir = node_path.default.relative(resolvedRoot, resolvedOutDir);
+		if (relativeOutDir && !relativeOutDir.startsWith("..") && !node_path.default.isAbsolute(relativeOutDir)) ignore.push(`${relativeOutDir.split(node_path.default.sep).join("/")}/**`);
+	}
+	const candidates = await (0, fast_glob.default)(VITE_TAILWIND_CSS_ENTRY_PATTERN, {
+		absolute: true,
+		cwd: resolvedRoot,
+		ignore,
+		onlyFiles: true,
+		unique: true
+	});
+	const entries = [];
+	for (const file of candidates) {
+		if (!await pathExistsAsFile(file)) continue;
+		try {
+			const css = (0, node_fs.readFileSync)(file, "utf8");
+			if (css.includes("tailwindcss") || css.includes("@source") || css.includes("@config")) {
+				if (await resolveTailwindV4EntriesFromCssCached(css, node_path.default.dirname(file))) entries.push(file);
+			}
+		} catch {}
+	}
+	return entries;
+}
+function collectConfiguredCssSources(options) {
+	return [...options.tailwindcss?.v4?.cssSources ?? [], ...options.tailwindcssPatcherOptions?.tailwindcss?.v4?.cssSources ?? []];
+}
+async function resolveViteSourceScanEntries(options, patcher, scanOptions = {}) {
+	if (patcher.majorVersion === 3) {
+		const source = await resolveTailwindV3SourceFromPatcher(patcher);
+		const contentEntries = normalizeLegacyContentEntries(source.configObject?.content, source.config ? node_path.default.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 && node_path.default.resolve(scanRoot) === node_path.default.resolve(sourceProjectRoot)) {
+				const discoveredCssEntries = await discoverTailwindV4CssEntries(scanRoot, scanOptions.outDir);
+				cssEntries.push(...discoveredCssEntries);
+			}
+		}
+		const entries = [];
+		const cssInlineCandidates = [];
+		const dependencies = /* @__PURE__ */ new Set();
+		let explicit = false;
+		for (const cssEntry of cssEntries) {
+			addSourceScanDependency(dependencies, cssEntry);
+			const resolved = await resolveTailwindV4EntriesFromCssCached((0, node_fs.readFileSync)(cssEntry, "utf8"), node_path.default.dirname(cssEntry));
+			if (resolved) {
+				entries.push(...resolved.entries);
+				cssInlineCandidates.push(resolved.inlineCandidates);
+				addSourceScanDependencies(dependencies, resolved.dependencies);
+				explicit || (explicit = resolved.explicit);
+			}
+		}
+		const inlineCandidates = mergeTailwindInlineSourceCandidates(cssInlineCandidates);
+		if (entries.length > 0 || inlineCandidates || explicit || cssEntries.length > 0) 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 ?? node_process.default.cwd());
+			return resolved ? createResolvedViteSourceScan({
+				entries: resolved.explicit ? resolved.entries : resolved.entries.length > 0 ? resolved.entries : void 0,
+				explicit: resolved.explicit,
+				inlineCandidates: resolved.inlineCandidates
+			}, new Set(resolved.dependencies)) : void 0;
+		}
+		const sourceOptionBase = sourceOptions.base ?? sourceOptions.projectRoot ?? node_process.default.cwd();
+		const configuredCssSources = collectConfiguredCssSources(options);
+		for (const cssSource of [...configuredCssSources, ...sourceOptions.cssSources ?? []]) {
+			if (typeof cssSource.css !== "string" || cssSource.css.length === 0) continue;
+			addSourceScanDependency(dependencies, cssSource.file);
+			addSourceScanDependencies(dependencies, cssSource.dependencies);
+			const resolved = await resolveTailwindV4EntriesFromCssCached(cssSource.css, 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 || sourceOptions.cssSources?.length || configuredCssSources.length > 0) 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.explicit ? resolved.entries : resolved.entries.length > 0 ? resolved.entries : void 0,
+			explicit: resolved.explicit,
+			inlineCandidates: resolved.inlineCandidates
+		}, new Set([...dependencies, ...resolved.dependencies])) : void 0;
+	}
+}
+function createViteSourceScanMatcher(entries) {
+	return createTailwindSourceEntryMatcher(entries);
+}
+//#endregion
+//#region src/tailwindcss/runtime/cache.ts
+const runtimeClassSetCache = /* @__PURE__ */ new WeakMap();
+const runtimeFileSignatureCache = /* @__PURE__ */ new Map();
+const runtimeTrackedSourceFilesCache = /* @__PURE__ */ new Map();
+let runtimeFileSignatureCacheClearTimer;
+const 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 = (0, node_fs.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 (!(0, node_fs.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 (!(0, node_fs.existsSync)(cssEntry)) continue;
+		const resolved = await resolveTailwindV4EntriesFromCssCached((0, node_fs.readFileSync)(cssEntry, "utf8"), node_path.default.dirname(cssEntry));
+		const expanded = resolved?.entries?.length ? await expandTailwindSourceEntries(resolved.entries) : [];
+		for (const file of expanded) files.add(file);
+	}
+	for (const cssSource of tailwindOptions?.v4?.cssSources ?? []) {
+		if (typeof cssSource.css !== "string" || cssSource.css.length === 0) continue;
+		const base = typeof cssSource.file === "string" && cssSource.file.length > 0 ? node_path.default.dirname(cssSource.file) : tailwindOptions?.v4?.base ?? tailwindOptions?.cwd ?? twPatcher.options?.projectRoot ?? node_process.default.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$1 = createDebug("[tailwindcss:runtime-patch] ");
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+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 = node_path.default.resolve(rootPath);
+	let count = 0;
+	for (const id of Object.keys(require$1.cache)) {
+		const normalizedId = node_path.default.resolve(id);
+		if (normalizedId === normalizedRoot || normalizedId.startsWith(`${normalizedRoot}${node_path.default.sep}`)) {
+			delete require$1.cache[id];
+			count += 1;
+		}
+	}
+	if (count > 0) debug$1("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$1("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 = (0, _weapp_tailwindcss_postcss.createStyleHandler)({
+	cssChildCombinatorReplaceValue: ["view", "text"],
+	cssRemoveHoverPseudoClass: true,
+	isMainChunk: true,
+	majorVersion: 3
+});
+const MINI_PROGRAM_V3_PREFLIGHT_SELECTORS = new Set([
+	"view,text,:before,:after",
+	"view,text,:after,:before",
+	"view,text,::before,::after",
+	"view,text,::after,::before"
+]);
+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 MINI_PROGRAM_V3_PREFLIGHT_SELECTORS.has(normalizeSelector(rule.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.default.decl({
+		prop,
+		value: value.toString()
+	}));
+}
+function ensureMiniProgramV3PreflightReset(css, cssPreflight) {
+	const declarations = createPreflightDeclarations(cssPreflight);
+	if (declarations.length === 0) return css;
+	try {
+		const root = postcss.default.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((0, _weapp_tailwindcss_postcss.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 collectApplyCandidatesFromCss(css) {
+	if (!css.includes("@apply")) return [];
+	const candidates = /* @__PURE__ */ new Set();
+	try {
+		postcss.default.parse(css).walkAtRules("apply", (rule) => {
+			for (const candidate of rule.params.split(/\s+/)) {
+				const normalized = candidate.replace(/!important$/, "").trim();
+				if (normalized) candidates.add(normalized);
+			}
+		});
+	} catch {}
+	return [...candidates];
+}
+function isTailwindCandidateLayer(params) {
+	return params.split(/[,\s]+/).some((layer) => layer === "components" || layer === "utilities");
+}
+function extractClassCandidatesFromSelector(selector, candidates) {
+	for (let index = 0; index < selector.length; index++) {
+		if (selector[index] !== ".") continue;
+		let candidate = "";
+		let escaped = false;
+		for (let tokenIndex = index + 1; tokenIndex < selector.length; tokenIndex++) {
+			const char = selector[tokenIndex];
+			if (escaped) {
+				candidate += char;
+				escaped = false;
+				continue;
+			}
+			if (char === "\\") {
+				escaped = true;
+				continue;
+			}
+			if (/[\w-]/.test(char)) {
+				candidate += char;
+				continue;
+			}
+			break;
+		}
+		if (candidate) candidates.add(candidate);
+	}
+}
+function collectLayerCandidatesFromCss(css) {
+	if (!css.includes("@layer")) return [];
+	const candidates = /* @__PURE__ */ new Set();
+	try {
+		postcss.default.parse(css).walkAtRules("layer", (layer) => {
+			if (!isTailwindCandidateLayer(layer.params)) return;
+			layer.walkRules((rule) => {
+				extractClassCandidatesFromSelector(rule.selector, candidates);
+			});
+		});
+	} catch {}
+	return [...candidates];
+}
+function mergeGenerateCandidates(source, options) {
+	return collectCandidates([
+		...collectLayerCandidatesFromCss(source.css),
+		...collectApplyCandidatesFromCss(source.css),
+		...collectCandidates(options.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(mergeGenerateCandidates(source, options), options.sources ?? []);
+	config.content = hasExplicitContentInput(options) ? createExplicitContentConfig(rawEntries) : mergeContent(config.content, rawEntries);
+	return config;
+}
+function loadTailwindV3Internals(source) {
+	const requireFromProject = (0, node_module.createRequire)(`${source.cwd}/package.json`);
+	const requireFromRuntime = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+	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 = node_fs.default.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 candidates = mergeGenerateCandidates(generateSource, options);
+		const changedContent = createChangedContentEntries(candidates, options.sources ?? []);
+		const root = postcss.default.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, ...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: 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.default.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 = mergeGenerateCandidates(source, options);
+		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 node_path.default.isAbsolute(value) ? value : node_path.default.resolve(base, value);
+}
+function resolveCssConfig(css, base) {
+	if (!css) return {
+		css,
+		config: void 0
+	};
+	const root = postcss.default.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 ?? node_process.default.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 ?? node_process.default.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 ? node_path.default.dirname(config) : projectRoot);
+	const loaded = await (0, tailwindcss_config.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
+Object.defineProperty(exports, "DEFAULT_SOURCE_SCAN_EXTENSIONS", {
+	enumerable: true,
+	get: function() {
+		return DEFAULT_SOURCE_SCAN_EXTENSIONS;
+	}
+});
+Object.defineProperty(exports, "FULL_SOURCE_SCAN_EXTENSION_RE", {
+	enumerable: true,
+	get: function() {
+		return FULL_SOURCE_SCAN_EXTENSION_RE;
+	}
+});
+Object.defineProperty(exports, "collectCssInlineSourceCandidates", {
+	enumerable: true,
+	get: function() {
+		return collectCssInlineSourceCandidates;
+	}
+});
+Object.defineProperty(exports, "createDebug", {
+	enumerable: true,
+	get: function() {
+		return createDebug;
+	}
+});
+Object.defineProperty(exports, "createSourceScanPattern", {
+	enumerable: true,
+	get: function() {
+		return createSourceScanPattern;
+	}
+});
+Object.defineProperty(exports, "createTailwindV3Engine", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV3Engine;
+	}
+});
+Object.defineProperty(exports, "createTailwindV4Engine", {
+	enumerable: true,
+	get: function() {
+		return createTailwindV4Engine;
+	}
+});
+Object.defineProperty(exports, "createTailwindcssPatcher", {
+	enumerable: true,
+	get: function() {
+		return createTailwindcssPatcher;
+	}
+});
+Object.defineProperty(exports, "createViteSourceScanMatcher", {
+	enumerable: true,
+	get: function() {
+		return createViteSourceScanMatcher;
+	}
+});
+Object.defineProperty(exports, "discoverTailwindV4CssEntries", {
+	enumerable: true,
+	get: function() {
+		return discoverTailwindV4CssEntries;
+	}
+});
+Object.defineProperty(exports, "ensureTailwindcssRuntimePatch", {
+	enumerable: true,
+	get: function() {
+		return ensureTailwindcssRuntimePatch;
+	}
+});
+Object.defineProperty(exports, "expandTailwindSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return expandTailwindSourceEntries;
+	}
+});
+Object.defineProperty(exports, "filterUnsupportedMiniProgramTailwindV4Candidates", {
+	enumerable: true,
+	get: function() {
+		return filterUnsupportedMiniProgramTailwindV4Candidates;
+	}
+});
+Object.defineProperty(exports, "findNearestPackageRoot", {
+	enumerable: true,
+	get: function() {
+		return findNearestPackageRoot;
+	}
+});
+Object.defineProperty(exports, "findTailwindConfig", {
+	enumerable: true,
+	get: function() {
+		return findTailwindConfig;
+	}
+});
+Object.defineProperty(exports, "findWorkspacePackageDir", {
+	enumerable: true,
+	get: function() {
+		return findWorkspacePackageDir;
+	}
+});
+Object.defineProperty(exports, "findWorkspaceRoot", {
+	enumerable: true,
+	get: function() {
+		return findWorkspaceRoot;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetCacheEntry", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetCacheEntry;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetSignature", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetSignature;
+	}
+});
+Object.defineProperty(exports, "getRuntimeClassSetSignatureWithSources", {
+	enumerable: true,
+	get: function() {
+		return getRuntimeClassSetSignatureWithSources;
+	}
+});
+Object.defineProperty(exports, "invalidateRuntimeClassSet", {
+	enumerable: true,
+	get: function() {
+		return invalidateRuntimeClassSet;
+	}
+});
+Object.defineProperty(exports, "isFileMatchedByTailwindSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return isFileMatchedByTailwindSourceEntries;
+	}
+});
+Object.defineProperty(exports, "normalizeLegacyContentEntries", {
+	enumerable: true,
+	get: function() {
+		return normalizeLegacyContentEntries;
+	}
+});
+Object.defineProperty(exports, "omitUndefined", {
+	enumerable: true,
+	get: function() {
+		return omitUndefined;
+	}
+});
+Object.defineProperty(exports, "parseConfigParam", {
+	enumerable: true,
+	get: function() {
+		return parseConfigParam$1;
+	}
+});
+Object.defineProperty(exports, "readInstalledPackageMajorVersion", {
+	enumerable: true,
+	get: function() {
+		return readInstalledPackageMajorVersion;
+	}
+});
+Object.defineProperty(exports, "resolveCssSourceEntries", {
+	enumerable: true,
+	get: function() {
+		return resolveCssSourceEntries;
+	}
+});
+Object.defineProperty(exports, "resolveSourceScanPath", {
+	enumerable: true,
+	get: function() {
+		return resolveSourceScanPath;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV3Source", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV3Source;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV3SourceFromPatcher", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV3SourceFromPatcher;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV3SourceOptionsFromPatcher", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV3SourceOptionsFromPatcher;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4CssSourceBase", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4CssSourceBase;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4EntriesFromCss", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4EntriesFromCss;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4EntriesFromCssCached", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4EntriesFromCssCached;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4Source", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4Source;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4SourceFromPatcher", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4SourceFromPatcher;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindV4SourceOptionsFromPatcher", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindV4SourceOptionsFromPatcher;
+	}
+});
+Object.defineProperty(exports, "resolveTailwindcssOptions", {
+	enumerable: true,
+	get: function() {
+		return resolveTailwindcssOptions;
+	}
+});
+Object.defineProperty(exports, "resolveViteSourceScanEntries", {
+	enumerable: true,
+	get: function() {
+		return resolveViteSourceScanEntries;
+	}
+});
+Object.defineProperty(exports, "resolveViteTailwindV4CssDependencies", {
+	enumerable: true,
+	get: function() {
+		return resolveViteTailwindV4CssDependencies;
+	}
+});
+Object.defineProperty(exports, "runtimeSignaturePatchersSymbol", {
+	enumerable: true,
+	get: function() {
+		return runtimeSignaturePatchersSymbol;
+	}
+});
+Object.defineProperty(exports, "toPosixPath", {
+	enumerable: true,
+	get: function() {
+		return toPosixPath;
+	}
+});
+Object.defineProperty(exports, "transformTailwindV3CssByTarget", {
+	enumerable: true,
+	get: function() {
+		return transformTailwindV3CssByTarget;
+	}
+});
+Object.defineProperty(exports, "transformTailwindV3CssToWeapp", {
+	enumerable: true,
+	get: function() {
+		return transformTailwindV3CssToWeapp;
+	}
+});
+Object.defineProperty(exports, "transformTailwindV4CssByTarget", {
+	enumerable: true,
+	get: function() {
+		return transformTailwindV4CssByTarget;
+	}
+});
+Object.defineProperty(exports, "transformTailwindV4CssToWeapp", {
+	enumerable: true,
+	get: function() {
+		return transformTailwindV4CssToWeapp;
+	}
+});