@weapp-tailwindcss/cli 4.0.0-alpha.8 → 5.3.0

package/dist/src-C97Lmsr-.cjs

@@ -0,0 +1,1067 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_process = require("node:process");
+node_process = __toESM(node_process, 1);
+let _weapp_tailwindcss_logger = require("@weapp-tailwindcss/logger");
+let semver = require("semver");
+semver = __toESM(semver, 1);
+let node_buffer = require("node:buffer");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = __toESM(node_fs_promises, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let _tailwindcss_mangle_engine = require("@tailwindcss-mangle/engine");
+let lightningcss = require("lightningcss");
+let weapp_tailwindcss_generator = require("weapp-tailwindcss/generator");
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs, 1);
+let node_crypto = require("node:crypto");
+let _parcel_watcher = require("@parcel/watcher");
+_parcel_watcher = __toESM(_parcel_watcher, 1);
+let fast_glob = require("fast-glob");
+fast_glob = __toESM(fast_glob, 1);
+let node_readline = require("node:readline");
+let node_module = require("node:module");
+//#region src/build/args.ts
+function value(argv, index, flag) {
+	const item = argv[index];
+	return (item?.startsWith(`${flag}=`) ? item.slice(flag.length + 1) : void 0) ?? argv[index + 1];
+}
+function parseBuildArgs(argv) {
+	let cwd = node_process.default.cwd();
+	let input;
+	let output;
+	let watch = false;
+	let watchMode = "native";
+	let pollInterval = 250;
+	let minify = false;
+	let optimize = false;
+	let map = false;
+	let silent = false;
+	let target = "web";
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		const consumesNext = !arg.includes("=");
+		if (arg === "--cwd" || arg.startsWith("--cwd=")) {
+			cwd = node_path.default.resolve(value(argv, index, "--cwd"));
+			if (consumesNext) index++;
+		} else if (arg === "-i" || arg === "--input" || arg.startsWith("--input=")) {
+			input = value(argv, index, arg === "-i" ? "-i" : "--input");
+			if (consumesNext) index++;
+		} else if (arg === "-o" || arg === "--output" || arg.startsWith("--output=")) {
+			output = value(argv, index, arg === "-o" ? "-o" : "--output");
+			if (consumesNext) index++;
+		} else if (arg === "-w" || arg === "--watch") watch = true;
+		else if (arg.startsWith("--watch=")) {
+			if (value(argv, index, "--watch") !== "always") throw new Error("Option \"--watch\" only accepts \"always\".");
+			watch = "always";
+		} else if (arg === "--poll") {
+			watchMode = "poll";
+			pollInterval = 250;
+		} else if (arg.startsWith("--poll=")) {
+			watchMode = "poll";
+			pollInterval = Number(value(argv, index, "--poll"));
+			if (!Number.isFinite(pollInterval) || pollInterval <= 0) throw new Error("Specified polling interval must be a positive number.");
+		} else if (arg === "-m" || arg === "--minify") minify = true;
+		else if (arg === "--optimize") optimize = true;
+		else if (arg === "--silent") silent = true;
+		else if (arg === "--map") {
+			const next = argv[index + 1];
+			if (next && !next.startsWith("-")) {
+				if (next === "-") throw new Error("Use --map without a value to inline the source map.");
+				map = next;
+				index++;
+			} else map = true;
+		} else if (arg.startsWith("--map=")) {
+			const next = value(argv, index, "--map");
+			if (next === "-") throw new Error("Use --map without a value to inline the source map.");
+			map = next;
+		} else if (arg === "--target" || arg.startsWith("--target=")) {
+			const next = value(argv, index, "--target");
+			if (next !== "web" && next !== "weapp") throw new Error("Option \"--target\" must be \"web\" or \"weapp\".");
+			target = next;
+			if (consumesNext) index++;
+		} else throw new Error(`Unknown option: ${arg}`);
+	}
+	const resolvePath = (file) => file && file !== "-" ? node_path.default.resolve(cwd, file) : file;
+	input = resolvePath(input);
+	output = resolvePath(output);
+	if (typeof map === "string") map = node_path.default.resolve(cwd, map);
+	if (input && input !== "-" && !node_fs.default.existsSync(input)) throw new Error(`Specified input file ${input} does not exist.`);
+	if (input && input !== "-" && input === output) throw new Error("Specified input and output files are identical.");
+	if (target === "weapp" && map) throw new Error("Option \"--map\" is only supported when \"--target web\" is used.");
+	return {
+		cwd,
+		input,
+		output,
+		watch,
+		watchMode,
+		pollInterval,
+		minify,
+		optimize,
+		map,
+		silent,
+		target
+	};
+}
+//#endregion
+//#region src/build/watch.ts
+async function snapshot(cwd, dependencies, output) {
+	const files = /* @__PURE__ */ new Set([...dependencies, ...await (0, fast_glob.default)("**/*", {
+		cwd,
+		absolute: true,
+		dot: true,
+		onlyFiles: true,
+		ignore: ["node_modules/**", ".git/**"]
+	})]);
+	if (output && output !== "-") files.delete(node_path.default.resolve(output));
+	const state = /* @__PURE__ */ new Map();
+	await Promise.all([...files].map(async (file) => {
+		try {
+			const [stat, content] = await Promise.all([node_fs_promises.default.stat(file), node_fs_promises.default.readFile(file)]);
+			const digest = (0, node_crypto.createHash)("sha256").update(content).digest("hex");
+			state.set(node_path.default.resolve(file), `${stat.mtimeMs}:${stat.size}:${digest}`);
+		} catch {}
+	}));
+	return state;
+}
+function changed(previous, next) {
+	if (previous.size !== next.size) return true;
+	for (const [file, value] of next) if (previous.get(file) !== value) return true;
+	return false;
+}
+async function watchBuildInputs(options) {
+	if (options.mode === "native") try {
+		return await watchWithNativeWatcher(options);
+	} catch (error) {
+		node_process.default.stderr.write(`Native watcher unavailable, falling back to polling: ${error instanceof Error ? error.message : String(error)}\n`);
+		return watchWithPolling(options);
+	}
+	return watchWithPolling(options);
+}
+async function watchWithPolling(options) {
+	let dependencies = /* @__PURE__ */ new Set();
+	const previous = await snapshot(options.cwd, dependencies, options.output);
+	dependencies = await options.rebuild();
+	const initialized = await snapshot(options.cwd, dependencies, options.output);
+	for (const [file, value] of initialized) if (!previous.has(file)) previous.set(file, value);
+	await new Promise((resolve) => {
+		let running = false;
+		const timer = setInterval(async () => {
+			if (running) return;
+			running = true;
+			try {
+				const next = await snapshot(options.cwd, dependencies, options.output);
+				if (changed(previous, next)) {
+					previous.clear();
+					for (const [file, value] of next) previous.set(file, value);
+					dependencies = await options.rebuild();
+				}
+			} catch (error) {
+				node_process.default.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+			} finally {
+				running = false;
+			}
+		}, options.interval);
+		const stop = () => {
+			clearInterval(timer);
+			resolve();
+		};
+		node_process.default.once("SIGINT", stop);
+		node_process.default.once("SIGTERM", stop);
+	});
+}
+function parentDirectories(files, cwd) {
+	const directories = /* @__PURE__ */ new Set([node_path.default.resolve(cwd)]);
+	for (const file of files) {
+		const absolute = node_path.default.resolve(file);
+		if (!absolute.startsWith(`${node_path.default.resolve(cwd)}${node_path.default.sep}`)) directories.add(node_path.default.dirname(absolute));
+	}
+	return directories;
+}
+async function watchWithNativeWatcher(options) {
+	let dependencies = /* @__PURE__ */ new Set();
+	const subscriptions = /* @__PURE__ */ new Map();
+	let running = false;
+	let pending = false;
+	let resolvePending;
+	const output = options.output && options.output !== "-" ? node_path.default.resolve(options.output) : void 0;
+	const requestRebuild = () => {
+		pending = true;
+		resolvePending?.();
+	};
+	const syncSubscriptions = async () => {
+		const directories = parentDirectories(dependencies, options.cwd);
+		for (const directory of directories) {
+			if (subscriptions.has(directory)) continue;
+			const subscription = await _parcel_watcher.subscribe(directory, (error, events) => {
+				if (error) {
+					node_process.default.stderr.write(`${error.message}\n`);
+					return;
+				}
+				if (events.some((event) => !output || node_path.default.resolve(event.path) !== output)) requestRebuild();
+			}, { ignore: ["**/node_modules/**", "**/.git/**"] });
+			subscriptions.set(directory, subscription);
+		}
+		for (const [directory, subscription] of subscriptions) if (!directories.has(directory)) {
+			await subscription.unsubscribe();
+			subscriptions.delete(directory);
+		}
+	};
+	await syncSubscriptions();
+	dependencies = await options.rebuild();
+	await syncSubscriptions();
+	await new Promise((resolve) => {
+		const stop = () => {
+			Promise.all([...subscriptions.values()].map((subscription) => subscription.unsubscribe())).finally(resolve);
+		};
+		node_process.default.once("SIGINT", stop);
+		node_process.default.once("SIGTERM", stop);
+		const loop = async () => {
+			while (true) {
+				if (pending) break;
+				await new Promise((wake) => {
+					resolvePending = wake;
+				});
+				resolvePending = void 0;
+			}
+			if (running) return;
+			running = true;
+			pending = false;
+			try {
+				dependencies = await options.rebuild();
+				await syncSubscriptions();
+			} catch (error) {
+				node_process.default.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+			} finally {
+				running = false;
+				if (pending) loop();
+			}
+		};
+		loop();
+	});
+}
+//#endregion
+//#region src/canonicalize.ts
+function splitCandidates(input) {
+	const result = [];
+	let token = "";
+	let depth = 0;
+	let quote = "";
+	for (const char of input.trim()) {
+		if (quote) {
+			token += char;
+			if (char === quote) quote = "";
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			quote = char;
+			token += char;
+			continue;
+		}
+		if (char === "[" || char === "(") depth++;
+		if (char === "]" || char === ")") depth--;
+		if (/\s/.test(char) && depth === 0) {
+			if (token) result.push(token);
+			token = "";
+			continue;
+		}
+		token += char;
+	}
+	if (token) result.push(token);
+	return result;
+}
+function canonicalize(designSystem, input) {
+	const candidates = designSystem.canonicalizeCandidates(splitCandidates(input), {
+		collapse: true,
+		logicalToPhysical: true
+	});
+	return designSystem.getClassOrder(candidates).sort(([, a], [, b]) => a === b ? 0 : a === null ? -1 : b === null ? 1 : a < b ? -1 : 1).map(([candidate]) => candidate).join(" ");
+}
+function record(designSystem, input) {
+	const output = canonicalize(designSystem, input);
+	return {
+		input,
+		output,
+		changed: input !== output
+	};
+}
+async function load(cssFile, cwd) {
+	const file = cssFile ? node_path.default.resolve(cwd, cssFile) : void 0;
+	const css = file ? await node_fs_promises.default.readFile(file, "utf8") : "@import \"tailwindcss\";";
+	const source = await (0, weapp_tailwindcss_generator.resolveTailwindV4Source)({
+		css,
+		base: file ? node_path.default.dirname(file) : cwd,
+		cwd,
+		projectRoot: cwd,
+		packageName: "tailwindcss"
+	});
+	return (0, weapp_tailwindcss_generator.loadTailwindV4DesignSystem)(source);
+}
+async function runCanonicalize(argv) {
+	let cssFile;
+	let format = "text";
+	let stream = false;
+	const inputs = [];
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		if (arg === "--css") cssFile = argv[++index];
+		else if (arg.startsWith("--css=")) cssFile = arg.slice(6);
+		else if (arg === "--format") format = argv[++index];
+		else if (arg.startsWith("--format=")) format = arg.slice(9);
+		else if (arg === "--stream") stream = true;
+		else inputs.push(arg);
+	}
+	if (![
+		"text",
+		"json",
+		"jsonl"
+	].includes(format)) throw new Error(`Invalid value for --format: ${format}`);
+	const designSystem = await load(cssFile, node_process.default.cwd());
+	if (stream) {
+		const records = [];
+		for await (const line of (0, node_readline.createInterface)({ input: node_process.default.stdin })) {
+			const item = record(designSystem, line);
+			if (format === "text") node_process.default.stdout.write(`${item.output}\n`);
+			else if (format === "jsonl") node_process.default.stdout.write(`${JSON.stringify(item)}\n`);
+			else records.push(item);
+		}
+		if (format === "json") node_process.default.stdout.write(JSON.stringify(records, null, 2));
+		return 0;
+	}
+	if (inputs.length === 0) {
+		for await (const line of (0, node_readline.createInterface)({ input: node_process.default.stdin })) if (line.trim()) inputs.push(line.trim());
+	}
+	if (inputs.length === 0) throw new Error("No candidate groups provided");
+	const records = inputs.map((input) => record(designSystem, input));
+	const output = format === "json" ? JSON.stringify(records, null, 2) : format === "jsonl" ? records.map(JSON.stringify).join("\n") : records.map((item) => item.output).join("\n");
+	node_process.default.stdout.write(`${output}\n`);
+	return 0;
+}
+//#endregion
+//#region src/build.ts
+const DEFAULT_INPUT = "@import \"tailwindcss\";";
+async function drainStdin() {
+	const chunks = [];
+	for await (const chunk of node_process.default.stdin) chunks.push(node_buffer.Buffer.from(chunk));
+	return node_buffer.Buffer.concat(chunks).toString();
+}
+async function writeFile$1(file, content) {
+	await node_fs_promises.default.mkdir(node_path.default.dirname(file), { recursive: true });
+	await node_fs_promises.default.writeFile(file, content);
+}
+function sourceMapComment(value) {
+	return `/*# sourceMappingURL=${value} */`;
+}
+async function buildOnce(options, stdinCss) {
+	const inputCss = options.input === "-" ? stdinCss ?? await drainStdin() : options.input ? await node_fs_promises.default.readFile(options.input, "utf8") : DEFAULT_INPUT;
+	const sourceOptions = {
+		base: options.input && options.input !== "-" ? node_path.default.dirname(options.input) : options.cwd,
+		projectRoot: options.cwd,
+		cwd: options.cwd,
+		packageName: "tailwindcss"
+	};
+	const source = await (0, weapp_tailwindcss_generator.resolveTailwindV4Source)({
+		...sourceOptions,
+		css: inputCss
+	});
+	const generator = (0, weapp_tailwindcss_generator.createWeappTailwindcssGenerator)(source);
+	try {
+		const { compiled, dependencies: compilerDependencies } = await (0, _tailwindcss_mangle_engine.compileTailwindV4Source)(source);
+		const scanPatterns = (0, _tailwindcss_mangle_engine.createTailwindV4CompiledSourceEntries)(compiled.root, compiled.sources, source.projectRoot);
+		const scanSources = (0, _tailwindcss_mangle_engine.normalizeTailwindV4ScannerSources)(scanPatterns, source.projectRoot);
+		const outputPath = options.output && options.output !== "-" ? node_path.default.resolve(options.output) : void 0;
+		const sourceFiles = await (0, _tailwindcss_mangle_engine.resolveProjectSourceFiles)({
+			cwd: source.projectRoot,
+			sources: scanSources,
+			filter: (file) => node_path.default.resolve(file) !== outputPath
+		});
+		const candidateGroups = await Promise.all(sourceFiles.map(async (file) => {
+			const content = await node_fs_promises.default.readFile(file, "utf8");
+			const extension = node_path.default.extname(file).slice(1) || "html";
+			return (0, _tailwindcss_mangle_engine.extractRawCandidatesWithPositions)(content, extension);
+		}));
+		const candidates = new Set(candidateGroups.flat().map((candidate) => candidate.rawCandidate));
+		const result = await generator.generate({
+			candidates,
+			target: options.target,
+			scanSources: false,
+			incrementalCache: false
+		});
+		let css = result.css;
+		let map;
+		if (options.minify || options.optimize || options.map) {
+			const transformed = (0, lightningcss.transform)({
+				filename: options.input && options.input !== "-" ? node_path.default.basename(options.input) : "input.css",
+				code: node_buffer.Buffer.from(css),
+				minify: options.minify,
+				sourceMap: Boolean(options.map)
+			});
+			css = node_buffer.Buffer.from(transformed.code).toString();
+			map = transformed.map;
+		}
+		if (options.map && map) {
+			if (options.map === true) css += `\n${sourceMapComment(`data:application/json;base64,${node_buffer.Buffer.from(map).toString("base64")}`)}`;
+			else {
+				await writeFile$1(options.map, map);
+				const mapBase = options.output && options.output !== "-" ? node_path.default.dirname(options.output) : options.cwd;
+				css += `\n${sourceMapComment(node_path.default.relative(mapBase, options.map))}`;
+			}
+		}
+		return {
+			css,
+			dependencies: /* @__PURE__ */ new Set([
+				...options.input && options.input !== "-" ? [options.input] : [],
+				...source.dependencies,
+				...compilerDependencies,
+				...result.dependencies,
+				...sourceFiles
+			])
+		};
+	} finally {
+		generator.dispose?.();
+	}
+}
+async function runBuild(argv) {
+	const options = parseBuildArgs(argv);
+	if (!options.silent) node_process.default.stderr.write(`tailwindcss v${node_process.default.env.npm_package_version ?? ""}\n\n`);
+	const stdinCss = options.input === "-" ? await drainStdin() : void 0;
+	let previous = "";
+	const rebuild = async () => {
+		const result = await buildOnce(options, stdinCss);
+		if (result.css !== previous) {
+			if (options.output && options.output !== "-") await writeFile$1(options.output, result.css);
+			else node_process.default.stdout.write(`${result.css}\n`);
+			previous = result.css;
+		}
+		return result.dependencies;
+	};
+	if (!options.watch || options.input === "-" && options.watch !== "always") {
+		await rebuild();
+		return 0;
+	}
+	await watchBuildInputs({
+		cwd: options.cwd,
+		interval: options.pollInterval,
+		mode: options.watchMode,
+		output: options.output,
+		rebuild
+	});
+	return 0;
+}
+async function runTailwindCli(rawArgv) {
+	if (rawArgv[0] === "canonicalize") return runCanonicalize(rawArgv.slice(1));
+	return runBuild(rawArgv[0] === "build" ? rawArgv.slice(1) : rawArgv);
+}
+//#endregion
+//#region package.json
+var version = "5.3.0";
+//#endregion
+//#region src/constants.ts
+const WEAPP_TW_REQUIRED_NODE_VERSION_RANGE = "^22.18.0 || >=24.11.0";
+const WEAPP_TW_VERSION = version;
+//#endregion
+//#region src/context.ts
+function formatOutputPath(target, baseDir) {
+	const root = baseDir ?? node_process.default.cwd();
+	const relative = node_path.default.relative(root, target);
+	if (!relative) return ".";
+	if (relative.startsWith("..")) return node_path.default.normalize(target);
+	return relative.startsWith(".") ? relative : `.${node_path.default.sep}${relative}`;
+}
+//#endregion
+//#region src/doctor/constants.ts
+const CONFIG_FILES = {
+	tailwind: [
+		"tailwind.config.js",
+		"tailwind.config.cjs",
+		"tailwind.config.mjs",
+		"tailwind.config.ts"
+	],
+	postcss: [
+		"postcss.config.js",
+		"postcss.config.cjs",
+		"postcss.config.mjs",
+		"postcss.config.ts"
+	],
+	vite: [
+		"vite.config.js",
+		"vite.config.mjs",
+		"vite.config.ts"
+	],
+	webpack: [
+		"webpack.config.js",
+		"webpack.config.cjs",
+		"webpack.config.ts"
+	]
+};
+const FRAMEWORK_DEPS = [
+	["@tarojs/taro", "Taro"],
+	["@dcloudio/uni-app", "uni-app"],
+	["@mpxjs/core", "MPX"],
+	["remax", "Remax"]
+];
+//#endregion
+//#region src/doctor.ts
+function tryReadJson(file) {
+	try {
+		return JSON.parse((0, node_fs.readFileSync)(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+function findFirstExisting(cwd, files) {
+	return files.find((file) => (0, node_fs.existsSync)(node_path.default.join(cwd, file)));
+}
+function readProjectPackageJson(cwd) {
+	return tryReadJson(node_path.default.join(cwd, "package.json"));
+}
+function readDependencyVersion(cwd, packageName) {
+	try {
+		return tryReadJson((0, node_module.createRequire)(node_path.default.join(cwd, "package.json")).resolve(`${packageName}/package.json`))?.version;
+	} catch {
+		return;
+	}
+}
+function collectDependencySpecs(pkg) {
+	return {
+		...pkg?.dependencies ?? {},
+		...pkg?.devDependencies ?? {},
+		...pkg?.optionalDependencies ?? {},
+		...pkg?.peerDependencies ?? {}
+	};
+}
+function detectPackageManager(cwd, pkg) {
+	if (pkg?.packageManager) return pkg.packageManager;
+	if ((0, node_fs.existsSync)(node_path.default.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if ((0, node_fs.existsSync)(node_path.default.join(cwd, "package-lock.json"))) return "npm";
+	if ((0, node_fs.existsSync)(node_path.default.join(cwd, "yarn.lock"))) return "yarn";
+}
+function detectFrameworks(deps) {
+	return FRAMEWORK_DEPS.filter(([dependency]) => dependency in deps).map(([, label]) => label);
+}
+function addCheck(checks, check) {
+	checks.push(check);
+}
+function summarizeChecks(checks) {
+	return checks.reduce((summary, check) => {
+		summary[check.status] += 1;
+		return summary;
+	}, {
+		ok: 0,
+		warn: 0,
+		error: 0,
+		info: 0
+	});
+}
+function hasDependency(deps, packageName) {
+	return packageName in deps;
+}
+function getMajorVersion(version) {
+	if (!version) return;
+	return semver.default.parse(version)?.major;
+}
+function getDependencyMajor(deps, packageName) {
+	const spec = deps[packageName];
+	return spec ? semver.default.minVersion(spec)?.major : void 0;
+}
+function createDoctorReport(options = {}) {
+	const cwd = node_path.default.resolve(options.cwd ?? node_process.default.cwd());
+	const nodeVersion = options.nodeVersion ?? node_process.default.versions.node;
+	const pkg = readProjectPackageJson(cwd);
+	const deps = collectDependencySpecs(pkg);
+	const checks = [];
+	const packageManager = detectPackageManager(cwd, pkg);
+	const frameworks = detectFrameworks(deps);
+	const tailwindcssVersion = readDependencyVersion(cwd, "tailwindcss");
+	const weappTailwindcssVersion = readDependencyVersion(cwd, "weapp-tailwindcss");
+	const tailwindMajor = getMajorVersion(tailwindcssVersion) ?? getDependencyMajor(deps, "tailwindcss");
+	const tailwindConfig = findFirstExisting(cwd, CONFIG_FILES.tailwind);
+	const postcssConfig = findFirstExisting(cwd, CONFIG_FILES.postcss);
+	const viteConfig = findFirstExisting(cwd, CONFIG_FILES.vite);
+	const webpackConfig = findFirstExisting(cwd, CONFIG_FILES.webpack);
+	addCheck(checks, pkg ? {
+		id: "package-json",
+		title: "package.json",
+		status: "ok",
+		message: "已找到项目 package.json。"
+	} : {
+		id: "package-json",
+		title: "package.json",
+		status: "error",
+		message: "当前目录没有 package.json。",
+		suggestion: "请在项目根目录运行 doctor，或通过 --cwd 指向项目根目录。"
+	});
+	addCheck(checks, semver.default.satisfies(nodeVersion, "^22.18.0 || >=24.11.0") ? {
+		id: "node-version",
+		title: "Node.js",
+		status: "ok",
+		message: `当前 Node.js ${nodeVersion} 满足版本要求 ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE}。`
+	} : {
+		id: "node-version",
+		title: "Node.js",
+		status: "error",
+		message: `当前 Node.js ${nodeVersion} 不满足版本要求 ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE}。`,
+		suggestion: "请升级 Node.js 后再安装或构建 weapp-tailwindcss 项目。"
+	});
+	addCheck(checks, packageManager ? {
+		id: "package-manager",
+		title: "包管理器",
+		status: packageManager.startsWith("pnpm") ? "ok" : "info",
+		message: `检测到 ${packageManager}。`
+	} : {
+		id: "package-manager",
+		title: "包管理器",
+		status: "info",
+		message: "未检测到 lockfile 或 packageManager 字段。"
+	});
+	addCheck(checks, hasDependency(deps, "weapp-tailwindcss") || Boolean(weappTailwindcssVersion) ? {
+		id: "weapp-tailwindcss",
+		title: "weapp-tailwindcss",
+		status: "ok",
+		message: `检测到 weapp-tailwindcss${weappTailwindcssVersion ? `@${weappTailwindcssVersion}` : ""}。`
+	} : {
+		id: "weapp-tailwindcss",
+		title: "weapp-tailwindcss",
+		status: "warn",
+		message: "未在当前项目依赖中检测到 weapp-tailwindcss。",
+		suggestion: "如果这是业务项目，请安装 weapp-tailwindcss 并确认命令运行在项目根目录。"
+	});
+	addCheck(checks, hasDependency(deps, "tailwindcss") || Boolean(tailwindcssVersion) ? {
+		id: "tailwindcss",
+		title: "Tailwind CSS",
+		status: "ok",
+		message: `检测到 tailwindcss${tailwindcssVersion ? `@${tailwindcssVersion}` : ""}。`
+	} : {
+		id: "tailwindcss",
+		title: "Tailwind CSS",
+		status: "error",
+		message: "未检测到 tailwindcss。",
+		suggestion: "请安装 tailwindcss，并确认依赖可以从当前项目解析。"
+	});
+	addCheck(checks, tailwindConfig ? {
+		id: "tailwind-config",
+		title: "Tailwind 配置",
+		status: "ok",
+		message: `检测到 ${tailwindConfig}。`
+	} : {
+		id: "tailwind-config",
+		title: "Tailwind 配置",
+		status: tailwindMajor === 4 ? "info" : "warn",
+		message: "未检测到 tailwind.config.*。",
+		suggestion: tailwindMajor === 4 ? "Tailwind CSS v4 可以采用 CSS-first 配置；复杂 content/source 场景请补充配置文件。" : "请确认 Tailwind content/source 配置能够覆盖小程序页面、组件和脚本文件。"
+	});
+	addCheck(checks, postcssConfig ? {
+		id: "postcss-config",
+		title: "PostCSS 配置",
+		status: "ok",
+		message: `检测到 ${postcssConfig}。`
+	} : {
+		id: "postcss-config",
+		title: "PostCSS 配置",
+		status: viteConfig ? "info" : "warn",
+		message: "未检测到 postcss.config.*。",
+		suggestion: "如果通过 PostCSS 接入，请补充 postcss.config.*；如果通过 Vite/Taro 插件接入，可忽略此项。"
+	});
+	if (tailwindMajor === 4 && postcssConfig && !hasDependency(deps, "@tailwindcss/postcss")) addCheck(checks, {
+		id: "tailwindcss-v4-postcss",
+		title: "Tailwind v4 PostCSS",
+		status: "warn",
+		message: "Tailwind CSS v4 项目存在 PostCSS 配置，但未检测到 @tailwindcss/postcss。",
+		suggestion: "如果 PostCSS 配置中仍直接使用 tailwindcss，请迁移到 @tailwindcss/postcss。"
+	});
+	addCheck(checks, frameworks.length > 0 ? {
+		id: "framework",
+		title: "框架识别",
+		status: "ok",
+		message: `检测到 ${frameworks.join(", ")}。`
+	} : {
+		id: "framework",
+		title: "框架识别",
+		status: "info",
+		message: "未从依赖中识别出 Taro、uni-app、MPX 或 Remax。"
+	});
+	addCheck(checks, viteConfig || webpackConfig ? {
+		id: "bundler-config",
+		title: "构建器配置",
+		status: "ok",
+		message: `检测到 ${[viteConfig, webpackConfig].filter(Boolean).join(", ")}。`
+	} : {
+		id: "bundler-config",
+		title: "构建器配置",
+		status: "info",
+		message: "未检测到 vite.config.* 或 webpack.config.*。"
+	});
+	return {
+		cwd,
+		nodeVersion,
+		detected: {
+			packageManager,
+			frameworks,
+			tailwindcssVersion,
+			weappTailwindcssVersion
+		},
+		summary: summarizeChecks(checks),
+		checks
+	};
+}
+function hasDoctorFailure(report, strict = false) {
+	return report.summary.error > 0 || strict && report.summary.warn > 0;
+}
+function formatDoctorReport(report) {
+	const lines = [
+		`weapp-tailwindcss doctor`,
+		`cwd: ${report.cwd}`,
+		`summary: ${report.summary.error} error, ${report.summary.warn} warn, ${report.summary.ok} ok, ${report.summary.info} info`,
+		""
+	];
+	for (const check of report.checks) {
+		lines.push(`[${check.status}] ${check.title}: ${check.message}`);
+		if (check.suggestion) lines.push(`  -> ${check.suggestion}`);
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/helpers/options/parse.ts
+function readStringOption(flag, value) {
+	if (value == null) return;
+	if (typeof value !== "string") throw new TypeError(`Option "--${flag}" expects a string value.`);
+	const trimmed = value.trim();
+	if (trimmed.length === 0) throw new TypeError(`Option "--${flag}" expects a non-empty value.`);
+	return trimmed;
+}
+function readStringArrayOption(flag, value) {
+	if (value == null) return;
+	if (Array.isArray(value)) {
+		const normalized = value.filter((entry) => entry != null).map((entry) => {
+			if (typeof entry !== "string") throw new TypeError(`Option "--${flag}" expects string values.`);
+			const trimmed = entry.trim();
+			if (!trimmed) throw new TypeError(`Option "--${flag}" expects non-empty values.`);
+			return trimmed;
+		});
+		return normalized.length > 0 ? normalized : void 0;
+	}
+	const normalized = readStringOption(flag, value);
+	return normalized ? [normalized] : void 0;
+}
+function toBoolean(value, fallback) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		if (value === "true") return true;
+		if (value === "false") return false;
+	}
+	if (value == null) return fallback;
+	return Boolean(value);
+}
+//#endregion
+//#region src/helpers/options/resolve.ts
+function resolveCliCwd(value) {
+	const raw = readStringOption("cwd", value);
+	if (!raw) return;
+	return node_path.default.isAbsolute(raw) ? node_path.default.normalize(raw) : node_path.default.resolve(node_process.default.cwd(), raw);
+}
+//#endregion
+//#region src/helpers.ts
+async function ensureDir(dir) {
+	await (0, node_fs_promises.mkdir)(dir, { recursive: true });
+}
+function handleCliError(error) {
+	if (error instanceof Error) {
+		_weapp_tailwindcss_logger.logger.error(error.message);
+		if (error.stack && node_process.default.env["WEAPP_TW_DEBUG"] === "1") _weapp_tailwindcss_logger.logger.error(error.stack);
+	} else _weapp_tailwindcss_logger.logger.error(String(error));
+}
+function commandAction(handler) {
+	return async (...args) => {
+		try {
+			await handler(...args);
+		} catch (error) {
+			handleCliError(error);
+			node_process.default.exitCode = 1;
+		}
+	};
+}
+//#endregion
+//#region src/mount-options.ts
+const PATCH_COMMAND_OBSOLETE_NOTICE = "提示：weapp-tailwindcss@5 已由构建运行时接管 Tailwind CSS 处理，weapp-tw patch 已无需执行；请移除 package.json 中的 postinstall 钩子。";
+const obsoletePatchCommands = [
+	"extract",
+	"tokens",
+	"init",
+	"migrate",
+	"restore",
+	"validate"
+];
+function logPatchCommandObsoleteNotice() {
+	_weapp_tailwindcss_logger.logger.warn(PATCH_COMMAND_OBSOLETE_NOTICE);
+}
+function logObsoletePatchCommand(command) {
+	logPatchCommandObsoleteNotice();
+	_weapp_tailwindcss_logger.logger.warn(`命令 "${command}" 来自旧版 tailwindcss-patch 工作流，当前版本无需执行。`);
+}
+const DEFAULT_VSCODE_SOURCES = [
+	"not \"./dist\"",
+	"not \"./unpackage\"",
+	"./src/**/*.{wxml,axml,swan,qml,ttml,ux,uts}",
+	"./src/**/*.{js,jsx,ts,tsx,mjs,cjs,wxs,sjs}",
+	"./src/**/*.{vue,svelte,mpx,html,md,mdx}"
+];
+const SINGLE_QUOTE = "'";
+const DOUBLE_QUOTE = "\"";
+const BACKSLASH_RE = /\\/g;
+function toPosixPath(filepath) {
+	return filepath.replace(BACKSLASH_RE, "/");
+}
+async function assertFileExists(filepath) {
+	try {
+		await (0, node_fs_promises.access)(filepath, node_fs.constants.F_OK);
+	} catch (error) {
+		const err = error;
+		if (err?.code === "ENOENT") throw new Error(`CSS entry file not found: ${filepath}`);
+		throw err;
+	}
+}
+async function assertCanWrite(filepath, force) {
+	try {
+		await (0, node_fs_promises.access)(filepath, node_fs.constants.F_OK);
+		if (!force) throw new Error(`VS Code helper already exists at ${filepath}. Re-run with --force to overwrite it.`);
+	} catch (error) {
+		const err = error;
+		if (err?.code === "ENOENT") return;
+		throw err;
+	}
+}
+function toCssLiteral(value) {
+	const normalized = toPosixPath(value);
+	return JSON.stringify(normalized);
+}
+function formatSource(pattern) {
+	const trimmed = pattern.trim();
+	if (!trimmed) return null;
+	if (trimmed.startsWith("@source ")) return trimmed.endsWith(";") ? trimmed : `${trimmed};`;
+	let body = trimmed;
+	let keyword = "";
+	if (body.startsWith("not ")) {
+		keyword = "not ";
+		body = body.slice(4).trim();
+	} else if (body.startsWith("!")) {
+		keyword = "not ";
+		body = body.slice(1).trim();
+	}
+	if (!body) throw new Error("Invalid @source pattern: empty body.");
+	if (!body.startsWith(SINGLE_QUOTE) && !body.startsWith(DOUBLE_QUOTE)) body = toCssLiteral(body);
+	return `@source ${keyword}${body};`;
+}
+function resolveOutputPath(baseDir, output) {
+	const target = output ?? ".vscode/weapp-tailwindcss.intellisense.css";
+	return node_path.default.isAbsolute(target) ? node_path.default.normalize(target) : node_path.default.resolve(baseDir, target);
+}
+function resolveCssEntry(baseDir, entry) {
+	return node_path.default.isAbsolute(entry) ? node_path.default.normalize(entry) : node_path.default.resolve(baseDir, entry);
+}
+function toRelativeImport(fromFile, targetFile) {
+	const fromDir = node_path.default.dirname(fromFile);
+	let relative = node_path.default.relative(fromDir, targetFile);
+	if (!relative) relative = node_path.default.basename(targetFile);
+	if (!relative.startsWith(".")) relative = `./${relative}`;
+	return toPosixPath(relative);
+}
+async function generateVscodeIntellisenseEntry(options) {
+	const baseDir = options.baseDir;
+	const cssEntryPath = resolveCssEntry(baseDir, options.cssEntry);
+	await assertFileExists(cssEntryPath);
+	const outputPath = resolveOutputPath(baseDir, options.output);
+	await ensureDir(node_path.default.dirname(outputPath));
+	await assertCanWrite(outputPath, options.force);
+	const formattedSources = (options.sources && options.sources.length > 0 ? options.sources : DEFAULT_VSCODE_SOURCES).map(formatSource).filter((statement) => Boolean(statement));
+	const cssImport = toRelativeImport(outputPath, cssEntryPath);
+	const separator = formattedSources.length > 0 ? [""] : [];
+	const content = [
+		"/*",
+		" * Auto-generated by weapp-tailwindcss.",
+		" * This file exists solely to activate Tailwind CSS IntelliSense in VS Code.",
+		" * Do not import it in your actual mini-program bundles.",
+		" */",
+		"@import 'tailwindcss';",
+		"",
+		...formattedSources,
+		...separator,
+		`@import '${cssImport}';`,
+		""
+	].filter((line, idx, arr) => !(line === "" && arr[idx - 1] === "")).join("\n");
+	await (0, node_fs_promises.writeFile)(outputPath, `${content}\n`, "utf8");
+	return {
+		outputPath,
+		cssEntryPath
+	};
+}
+//#endregion
+//#region src/index.ts
+function parseLegacyArgs(argv) {
+	const options = {};
+	const positional = [];
+	for (let index = 0; index < argv.length; index++) {
+		const arg = argv[index];
+		if (arg === void 0) continue;
+		if (!arg.startsWith("--")) {
+			positional.push(arg);
+			continue;
+		}
+		const [rawKey, inlineValue] = arg.slice(2).split("=", 2);
+		if (!rawKey) continue;
+		const key = rawKey.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+		const next = argv[index + 1];
+		let value = true;
+		if (inlineValue !== void 0) value = inlineValue;
+		else if (next !== void 0 && !next.startsWith("-")) {
+			index++;
+			value = next;
+		}
+		const current = options[key];
+		if (current === void 0) options[key] = value;
+		else if (Array.isArray(current)) current.push(String(value));
+		else options[key] = [String(current), String(value)];
+	}
+	return {
+		command: positional[0],
+		options
+	};
+}
+function printHelp() {
+	_weapp_tailwindcss_logger.logger.log(`weapp-tailwindcss
+
+Usage:
+  weapp-tw [--input input.css] [--output output.css] [--watch] [options...]
+  weapp-tw build [--input input.css] [--output output.css] [--watch] [options...]
+  weapp-tw canonicalize [classes...]
+
+Build options:
+  -i, --input <file>       Input CSS file (use - for stdin)
+  -o, --output <file>      Output CSS file (defaults to stdout)
+  -w, --watch[=always]     Watch for changes and rebuild
+      --poll[=ms]          Use polling instead of the native watcher (default 250ms)
+  -m, --minify             Optimize and minify the output
+      --optimize           Optimize without minifying
+      --cwd <dir>          Set the working directory
+      --map[=<file>]       Generate a source map
+      --silent             Suppress non-error build output
+      --target <target>    CSS target: web (default) or weapp
+
+Additional commands:
+  canonicalize  Canonicalize Tailwind candidate lists
+  patch         Deprecated no-op: v5 runtime handles Tailwind CSS automatically
+  status        Deprecated no-op: patch status is no longer required
+  vscode-entry  Generate a VS Code helper CSS for Tailwind IntelliSense
+  doctor        Check project setup for weapp-tailwindcss
+`);
+}
+async function runPatch() {
+	logPatchCommandObsoleteNotice();
+	_weapp_tailwindcss_logger.logger.success("已跳过：当前版本不需要手动执行 Tailwind CSS patch。");
+}
+async function runStatus(options) {
+	const payload = {
+		required: false,
+		status: "unnecessary",
+		message: PATCH_COMMAND_OBSOLETE_NOTICE
+	};
+	if (toBoolean(options.json, false)) {
+		_weapp_tailwindcss_logger.logger.log(JSON.stringify(payload, null, 2));
+		return;
+	}
+	logPatchCommandObsoleteNotice();
+	_weapp_tailwindcss_logger.logger.success("无需检查 Tailwind CSS patch 状态。");
+}
+async function runVscodeEntry(options) {
+	const resolvedCwd = resolveCliCwd(options.cwd);
+	const baseDir = resolvedCwd ?? node_process.default.cwd();
+	const cssEntry = readStringOption("css", options.css);
+	if (!cssEntry) throw new Error("Option \"--css\" is required.");
+	const result = await generateVscodeIntellisenseEntry({
+		baseDir,
+		cssEntry,
+		output: readStringOption("output", options.output),
+		sources: readStringArrayOption("source", options.source),
+		force: toBoolean(options.force, false)
+	});
+	_weapp_tailwindcss_logger.logger.success(`VS Code helper generated -> ${formatOutputPath(result.outputPath, resolvedCwd)}`);
+}
+async function runDoctor(options) {
+	const report = createDoctorReport({ cwd: resolveCliCwd(options.cwd) });
+	_weapp_tailwindcss_logger.logger.log(toBoolean(options.json, false) ? JSON.stringify(report, null, 2) : formatDoctorReport(report));
+	if (hasDoctorFailure(report, toBoolean(options.strict, false))) node_process.default.exitCode = 1;
+}
+async function runCli(argv = node_process.default.argv.slice(2)) {
+	if (!semver.default.satisfies(node_process.default.versions.node, "^22.18.0 || >=24.11.0")) _weapp_tailwindcss_logger.logger.warn(`You are using Node.js ${node_process.default.versions.node}. For @weapp-tailwindcss/cli, Node.js version ${WEAPP_TW_REQUIRED_NODE_VERSION_RANGE} is required.`);
+	const { command, options } = parseLegacyArgs(argv);
+	await commandAction(async () => {
+		switch (command) {
+			case "patch":
+			case "install":
+				await runPatch();
+				return;
+			case "status":
+				await runStatus(options);
+				return;
+			case "vscode-entry":
+				await runVscodeEntry(options);
+				return;
+			case "doctor":
+				await runDoctor(options);
+				return;
+			case "help":
+				printHelp();
+				return;
+			case "version":
+				node_process.default.stdout.write(`${WEAPP_TW_VERSION}\n`);
+				return;
+			default: if (obsoletePatchCommands.includes(command ?? "")) {
+				logObsoletePatchCommand(command);
+				return;
+			}
+		}
+		if ((argv.includes("--help") || argv.includes("-h")) && command === void 0) {
+			printHelp();
+			return;
+		}
+		if (argv.includes("--version") || argv.includes("-v")) {
+			node_process.default.stdout.write(`${WEAPP_TW_VERSION}\n`);
+			return;
+		}
+		node_process.default.exitCode = await runTailwindCli(argv);
+	})();
+	return node_process.default.exitCode ?? 0;
+}
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "runCli", {
+	enumerable: true,
+	get: function() {
+		return runCli;
+	}
+});