postcss-tailwindcss 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ice breaker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,135 @@
+# postcss-tailwindcss
+
+PostCSS AST utilities for analyzing Tailwind CSS syntax.
+
+## Overview
+
+This package focuses on **analysis**, not transformation.
+
+It parses CSS with PostCSS and extracts Tailwind-related structures such as:
+
+- `@apply` utility candidates
+- `theme(...)` function calls
+- Tailwind v4 `@import "tailwindcss" ...` directives
+- utility-like class selectors declared in authored stylesheets
+- Tailwind runtime/config installation details from a consumer project
+
+The output is designed for tooling such as:
+
+- Stylelint plugins
+- codemods
+- custom lint rules
+- migration scripts
+- editor or CLI diagnostics
+
+## Installation
+
+```bash
+pnpm add -D postcss-tailwindcss
+```
+
+## When To Use This Package
+
+Use `postcss-tailwindcss` when:
+
+- you already work with PostCSS AST
+- you want tolerant parsing for Tailwind syntax
+- you need to inspect raw authored CSS rather than compile it
+- you need project-aware Tailwind runtime resolution
+
+If your toolchain is already built around Lightning CSS AST, use `lightningcss-tailwindcss` instead.
+
+## API
+
+- `parseTailwindCss(input)`
+- `detectTailwindVersion(input)`
+- `resolveTailwindRuntime(context)`
+- `detectInstalledTailwindVersion(context)`
+- `collectApplyCandidates(input)`
+- `collectThemeCalls(input)`
+- `collectImportDirectives(input)`
+- `collectUtilitySelectors(input)`
+- `analyzeTailwindCss(input)`
+
+`input` can be a CSS string or an existing PostCSS `Root`.
+
+`context` is:
+
+```ts
+interface TailwindResolutionContext {
+  cwd: string
+  tsconfigPath?: string
+}
+```
+
+## Example
+
+```ts
+import {
+  analyzeTailwindCss,
+  resolveTailwindRuntime,
+} from 'postcss-tailwindcss'
+
+const css = `
+@import "tailwindcss" source(none) prefix(tw);
+
+.button {
+  @apply flex hover:bg-red-500;
+  color: theme(colors.gray.900 / 75%);
+}
+`
+
+const analysis = analyzeTailwindCss(css)
+const runtime = resolveTailwindRuntime({
+  cwd: process.cwd(),
+})
+
+console.log(analysis.version)
+console.log(analysis.applyCandidates.map(item => item.candidate))
+console.log(runtime.version)
+console.log(runtime.configPath)
+```
+
+## Return Shape
+
+`analyzeTailwindCss()` returns:
+
+```ts
+interface TailwindAnalysis {
+  version: 3 | 4 | 'unknown'
+  applyCandidates: UtilityCandidate[]
+  themeCalls: ThemeCall[]
+  importDirectives: TailwindImportDirective[]
+  utilitySelectors: UtilitySelector[]
+}
+```
+
+Each item keeps a reference to the original PostCSS node so downstream tools can report precise diagnostics.
+
+## Runtime Resolution
+
+`resolveTailwindRuntime()` tries to discover:
+
+- installed `tailwindcss/package.json`
+- Tailwind installation directory
+- Tailwind CSS style entry
+- nearest `tailwind.config.*`
+- installed Tailwind version
+
+Resolution is project-aware:
+
+- default Node/package resolution is used first
+- if `tsconfigPath` is provided, `paths`/`baseUrl` are also considered via `get-tsconfig`
+
+## Parsing Notes
+
+- Tailwind v3 and v4 syntax are both recognized heuristically
+- `theme(colors.gray.900 / 75%)` is normalized into `path` and `opacity`
+- escaped selectors such as `.hover\\:bg-red-500:hover` are normalized back to `hover:bg-red-500`
+- this package does **not** validate whether a class is truly registered by Tailwind; it only extracts and normalizes syntax
+
+## Relationship To `stylelint-plugin-no-tailwindcss`
+
+`stylelint-plugin-no-tailwindcss` uses this package for selector collection and Tailwind runtime resolution.
+
+This package provides the low-level analysis layer; the Stylelint plugin provides the policy and reporting layer.

package/README.zh.md

@@ -0,0 +1,135 @@
+# postcss-tailwindcss
+
+用于分析 Tailwind CSS 语法的 PostCSS AST 工具集。
+
+## 概览
+
+这个包专注于**分析**，不负责 transform。
+
+它基于 PostCSS 解析 CSS，并提取下面这些 Tailwind 相关结构：
+
+- `@apply` 中的 utility candidate
+- `theme(...)` 函数调用
+- Tailwind v4 的 `@import "tailwindcss" ...` 指令
+- 手写样式里声明的 utility 风格类选择器
+- 使用方项目中的 Tailwind 安装、配置和版本信息
+
+适合用在：
+
+- Stylelint 插件
+- codemod
+- 自定义 lint rule
+- 迁移脚本
+- 编辑器或 CLI 诊断工具
+
+## 安装
+
+```bash
+pnpm add -D postcss-tailwindcss
+```
+
+## 适用场景
+
+推荐在这些情况下使用 `postcss-tailwindcss`：
+
+- 你的工具本身就是基于 PostCSS AST
+- 你希望更宽松地处理 Tailwind 语法
+- 你关注的是“源码分析”而不是“编译结果”
+- 你需要按项目路径解析 Tailwind 安装和配置
+
+如果你的工具链已经完全基于 Lightning CSS AST，优先使用 `lightningcss-tailwindcss`。
+
+## API
+
+- `parseTailwindCss(input)`
+- `detectTailwindVersion(input)`
+- `resolveTailwindRuntime(context)`
+- `detectInstalledTailwindVersion(context)`
+- `collectApplyCandidates(input)`
+- `collectThemeCalls(input)`
+- `collectImportDirectives(input)`
+- `collectUtilitySelectors(input)`
+- `analyzeTailwindCss(input)`
+
+`input` 可以是 CSS 字符串，也可以是已有的 PostCSS `Root`。
+
+`context` 结构如下：
+
+```ts
+interface TailwindResolutionContext {
+  cwd: string
+  tsconfigPath?: string
+}
+```
+
+## 示例
+
+```ts
+import {
+  analyzeTailwindCss,
+  resolveTailwindRuntime,
+} from 'postcss-tailwindcss'
+
+const css = `
+@import "tailwindcss" source(none) prefix(tw);
+
+.button {
+  @apply flex hover:bg-red-500;
+  color: theme(colors.gray.900 / 75%);
+}
+`
+
+const analysis = analyzeTailwindCss(css)
+const runtime = resolveTailwindRuntime({
+  cwd: process.cwd(),
+})
+
+console.log(analysis.version)
+console.log(analysis.applyCandidates.map(item => item.candidate))
+console.log(runtime.version)
+console.log(runtime.configPath)
+```
+
+## 返回结果
+
+`analyzeTailwindCss()` 返回：
+
+```ts
+interface TailwindAnalysis {
+  version: 3 | 4 | 'unknown'
+  applyCandidates: UtilityCandidate[]
+  themeCalls: ThemeCall[]
+  importDirectives: TailwindImportDirective[]
+  utilitySelectors: UtilitySelector[]
+}
+```
+
+每一项都会保留原始 PostCSS 节点引用，方便下游工具做精确报错。
+
+## Tailwind 运行时解析
+
+`resolveTailwindRuntime()` 会尝试解析：
+
+- 当前项目安装的 `tailwindcss/package.json`
+- Tailwind 安装目录
+- Tailwind CSS 样式入口
+- 最近的 `tailwind.config.*`
+- 已安装的 Tailwind 版本
+
+解析策略是项目感知的：
+
+- 默认先走标准 Node/package 解析
+- 如果传入 `tsconfigPath`，还会额外考虑 `paths` / `baseUrl`
+
+## 语法说明
+
+- 会对 Tailwind v3 / v4 语法做启发式识别
+- `theme(colors.gray.900 / 75%)` 会拆成 `path` 和 `opacity`
+- `.hover\\:bg-red-500:hover` 这类转义 selector 会被还原成 `hover:bg-red-500`
+- 这个包**不会**判断某个类名是否真的被 Tailwind 注册；它只负责提取和归一化语法
+
+## 与 `stylelint-plugin-no-tailwindcss` 的关系
+
+`stylelint-plugin-no-tailwindcss` 当前会复用这个包来做 selector 收集和 Tailwind 运行时解析。
+
+这个包是底层分析层，Stylelint 插件是在其上叠加规则策略和报错逻辑。

package/dist/index.d.ts

@@ -0,0 +1,69 @@
+import { AtRule, Declaration, Node, Root, Rule } from "postcss";
+
+//#region src/types.d.ts
+type TailwindVersion = 3 | 4 | 'unknown';
+interface TailwindResolutionContext {
+  cwd: string;
+  tsconfigPath?: string;
+}
+interface ResolvedTailwindRuntime {
+  configPath: string | null;
+  cssEntryPath: string | null;
+  installationPath: string | null;
+  packageJsonPath: string | null;
+  version: string | null;
+}
+interface UtilityCandidate {
+  candidate: string;
+  node: AtRule;
+  source?: Node['source'];
+}
+interface ThemeCall {
+  raw: string;
+  path: string;
+  opacity: string | null;
+  node: Declaration | AtRule;
+  source?: Node['source'];
+}
+interface TailwindImportDirective {
+  importTarget: string;
+  functions: Array<{
+    name: string;
+    value: string;
+  }>;
+  hasLayerKeyword: boolean;
+  mediaQuery: string | null;
+  node: AtRule;
+  source?: Node['source'];
+}
+interface UtilitySelector {
+  className: string;
+  rule: Rule;
+  selector: string;
+  source?: Node['source'];
+}
+interface TailwindAnalysis {
+  version: TailwindVersion;
+  applyCandidates: UtilityCandidate[];
+  themeCalls: ThemeCall[];
+  importDirectives: TailwindImportDirective[];
+  utilitySelectors: UtilitySelector[];
+}
+type TailwindInput = Root | string;
+//#endregion
+//#region src/analysis.d.ts
+declare function detectTailwindVersion(input: TailwindInput): TailwindVersion;
+declare function collectApplyCandidates(input: TailwindInput): UtilityCandidate[];
+declare function collectThemeCalls(input: TailwindInput): ThemeCall[];
+declare function collectImportDirectives(input: TailwindInput): TailwindImportDirective[];
+declare function collectUtilitySelectors(input: TailwindInput): UtilitySelector[];
+declare function analyzeTailwindCss(input: TailwindInput): TailwindAnalysis;
+//#endregion
+//#region src/postcss.d.ts
+declare function parseTailwindCss(input: TailwindInput): Root;
+//#endregion
+//#region src/runtime-resolution.d.ts
+declare function resolveTailwindRuntime(context: TailwindResolutionContext): ResolvedTailwindRuntime;
+declare function detectInstalledTailwindVersion(context: TailwindResolutionContext): TailwindVersion;
+//#endregion
+export { type ResolvedTailwindRuntime, type TailwindAnalysis, type TailwindImportDirective, type TailwindInput, type TailwindResolutionContext, type TailwindVersion, type ThemeCall, type UtilityCandidate, type UtilitySelector, analyzeTailwindCss, collectApplyCandidates, collectImportDirectives, collectThemeCalls, collectUtilitySelectors, detectInstalledTailwindVersion, detectTailwindVersion, parseTailwindCss, resolveTailwindRuntime };

package/dist/index.js

@@ -0,0 +1,408 @@
+import valueParser from "postcss-value-parser";
+import postcss from "postcss";
+import fs from "node:fs";
+import path from "node:path";
+import enhancedResolve from "enhanced-resolve";
+import { createPathsMatcher, getTsconfig, parseTsconfig } from "get-tsconfig";
+//#region src/constants.ts
+const ESCAPED_BACKSLASH_RE = /\\\\/g;
+const ESCAPED_CHAR_RE = /\\(.)/g;
+const WHITESPACE_RE = /\s/;
+const IMPORT_TARGET_RE = /^['"]|['"]$/g;
+const SELECTOR_BREAK_RE = /[#.,\s>+~]/;
+const TAILWIND_CONFIG_FILENAMES = [
+	"tailwind.config.ts",
+	"tailwind.config.mts",
+	"tailwind.config.cts",
+	"tailwind.config.js",
+	"tailwind.config.mjs",
+	"tailwind.config.cjs",
+	"tailwind.config.json"
+];
+const TAILWIND_V4_AT_RULES = [
+	"theme",
+	"source",
+	"utility",
+	"variant",
+	"custom-variant",
+	"plugin",
+	"reference"
+];
+const TAILWIND_IMPORT_FUNCTIONS = [
+	"source",
+	"prefix",
+	"layer",
+	"supports"
+];
+//#endregion
+//#region src/postcss.ts
+function toRoot(input) {
+	return typeof input === "string" ? postcss.parse(input) : input;
+}
+function parseTailwindCss(input) {
+	return toRoot(input);
+}
+//#endregion
+//#region src/syntax.ts
+function unescapeCssIdentifier(value) {
+	return value.replace(ESCAPED_BACKSLASH_RE, "\\").replace(ESCAPED_CHAR_RE, "$1");
+}
+function stripImportTargetQuotes(value) {
+	return value.replace(IMPORT_TARGET_RE, "");
+}
+function splitCandidateList(input) {
+	const candidates = [];
+	let current = "";
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	let quote = null;
+	let escaped = false;
+	for (const char of input) {
+		if (escaped) {
+			current += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			current += char;
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			current += char;
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'") {
+			current += char;
+			quote = char;
+			continue;
+		}
+		if (char === "[") {
+			bracketDepth += 1;
+			current += char;
+			continue;
+		}
+		if (char === "]") {
+			bracketDepth = Math.max(0, bracketDepth - 1);
+			current += char;
+			continue;
+		}
+		if (char === "(") {
+			parenDepth += 1;
+			current += char;
+			continue;
+		}
+		if (char === ")") {
+			parenDepth = Math.max(0, parenDepth - 1);
+			current += char;
+			continue;
+		}
+		if (WHITESPACE_RE.test(char) && bracketDepth === 0 && parenDepth === 0) {
+			const value = current.trim();
+			if (value) candidates.push(value);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	const last = current.trim();
+	if (last) candidates.push(last);
+	return candidates;
+}
+function parseThemeArgument(raw) {
+	let bracketDepth = 0;
+	let parenDepth = 0;
+	let slashIndex = -1;
+	for (let i = 0; i < raw.length; i += 1) {
+		const char = raw[i];
+		if (char === "[") bracketDepth += 1;
+		else if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		else if (char === "(") parenDepth += 1;
+		else if (char === ")") parenDepth = Math.max(0, parenDepth - 1);
+		else if (char === "/" && bracketDepth === 0 && parenDepth === 0) {
+			slashIndex = i;
+			break;
+		}
+	}
+	if (slashIndex === -1) return {
+		path: raw.trim(),
+		opacity: null
+	};
+	return {
+		path: raw.slice(0, slashIndex).trim(),
+		opacity: raw.slice(slashIndex + 1).trim() || null
+	};
+}
+function collectClassNamesFromSelector(selector) {
+	const classNames = [];
+	for (let index = 0; index < selector.length; index += 1) {
+		if (selector[index] !== ".") continue;
+		if (index > 0 && selector[index - 1] === "\\") continue;
+		let cursor = index + 1;
+		let rawClassName = "";
+		while (cursor < selector.length) {
+			const char = selector[cursor];
+			if (!char) break;
+			if ((SELECTOR_BREAK_RE.test(char) || char === ":") && selector[cursor - 1] !== "\\") break;
+			rawClassName += char;
+			cursor += 1;
+		}
+		if (rawClassName) classNames.push(unescapeCssIdentifier(rawClassName));
+		index = cursor - 1;
+	}
+	return classNames;
+}
+//#endregion
+//#region src/analysis.ts
+function hasTailwindV4Signals(root) {
+	let found = false;
+	root.walkAtRules((atRule) => {
+		if (TAILWIND_V4_AT_RULES.includes(atRule.name)) {
+			found = true;
+			return false;
+		}
+		if (atRule.name === "import" && atRule.params.includes("tailwindcss")) {
+			found = true;
+			return false;
+		}
+	});
+	if (found) return true;
+	root.walkDecls((decl) => {
+		if (decl.value.includes("--alpha(") || decl.value.includes("--spacing(")) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+}
+function hasTailwindV3Signals(root) {
+	let found = false;
+	root.walkAtRules((atRule) => {
+		if (["tailwind", "config"].includes(atRule.name)) {
+			found = true;
+			return false;
+		}
+	});
+	if (found) return true;
+	root.walkDecls((decl) => {
+		if (decl.value.includes("theme(")) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+}
+function detectTailwindVersion(input) {
+	const root = toRoot(input);
+	const hasV4 = hasTailwindV4Signals(root);
+	const hasV3 = hasTailwindV3Signals(root);
+	if (hasV4) return 4;
+	if (hasV3) return 3;
+	return "unknown";
+}
+function collectApplyCandidates(input) {
+	const root = toRoot(input);
+	const candidates = [];
+	root.walkAtRules("apply", (atRule) => {
+		for (const candidate of splitCandidateList(atRule.params)) candidates.push({
+			candidate,
+			node: atRule,
+			source: atRule.source
+		});
+	});
+	return candidates;
+}
+function collectThemeCallsFromNode(node, rawValue, calls) {
+	valueParser(rawValue).walk((valueNode) => {
+		if (valueNode.type !== "function" || valueNode.value !== "theme") return;
+		const raw = valueParser.stringify(valueNode.nodes).trim();
+		const { path, opacity } = parseThemeArgument(raw);
+		calls.push({
+			raw,
+			path,
+			opacity,
+			node,
+			source: node.source
+		});
+	});
+}
+function collectThemeCalls(input) {
+	const root = toRoot(input);
+	const calls = [];
+	root.walkDecls((decl) => {
+		collectThemeCallsFromNode(decl, decl.value, calls);
+	});
+	root.walkAtRules((atRule) => {
+		if (atRule.params.includes("theme(")) collectThemeCallsFromNode(atRule, atRule.params, calls);
+	});
+	return calls;
+}
+function collectImportDirectives(input) {
+	const root = toRoot(input);
+	const directives = [];
+	root.walkAtRules("import", (atRule) => {
+		if (!atRule.params.includes("tailwindcss")) return;
+		const parsed = valueParser(atRule.params);
+		let importTarget = "";
+		const functions = [];
+		let hasLayerKeyword = false;
+		let mediaQuery = null;
+		let sawImportTarget = false;
+		let mediaStartIndex = -1;
+		for (const [index, node] of parsed.nodes.entries()) {
+			if (node.type === "space") continue;
+			if (!sawImportTarget && (node.type === "string" || node.type === "function" && node.value === "url")) {
+				importTarget = stripImportTargetQuotes(valueParser.stringify(node.type === "function" ? node.nodes : [node]).trim());
+				sawImportTarget = true;
+				continue;
+			}
+			if (node.type === "function" && TAILWIND_IMPORT_FUNCTIONS.includes(node.value)) {
+				functions.push({
+					name: node.value,
+					value: valueParser.stringify(node.nodes).trim()
+				});
+				continue;
+			}
+			if (node.type === "word" && node.value === "layer") {
+				hasLayerKeyword = true;
+				continue;
+			}
+			mediaStartIndex = index;
+			break;
+		}
+		if (mediaStartIndex !== -1) mediaQuery = valueParser.stringify(parsed.nodes.slice(mediaStartIndex)).trim() || null;
+		directives.push({
+			importTarget,
+			functions,
+			hasLayerKeyword,
+			mediaQuery,
+			node: atRule,
+			source: atRule.source
+		});
+	});
+	return directives;
+}
+function collectUtilitySelectors(input) {
+	const root = toRoot(input);
+	const selectors = [];
+	root.walkRules((rule) => {
+		for (const className of collectClassNamesFromSelector(rule.selector)) selectors.push({
+			className,
+			rule,
+			selector: rule.selector,
+			source: rule.source
+		});
+	});
+	return selectors;
+}
+function analyzeTailwindCss(input) {
+	const root = toRoot(input);
+	return {
+		version: detectTailwindVersion(root),
+		applyCandidates: collectApplyCandidates(root),
+		themeCalls: collectThemeCalls(root),
+		importDirectives: collectImportDirectives(root),
+		utilitySelectors: collectUtilitySelectors(root)
+	};
+}
+//#endregion
+//#region src/runtime-resolution.ts
+const fileSystem = new enhancedResolve.CachedInputFileSystem(fs, 3e4);
+const pathsMatcherCache = /* @__PURE__ */ new Map();
+function getPathsMatcher(tsconfigPath) {
+	if (!tsconfigPath) return null;
+	const cached = pathsMatcherCache.get(tsconfigPath);
+	if (cached !== void 0) return cached;
+	let matcher = null;
+	try {
+		matcher = createPathsMatcher({
+			path: tsconfigPath,
+			config: parseTsconfig(tsconfigPath)
+		});
+	} catch {
+		const resolved = getTsconfig(path.dirname(tsconfigPath));
+		matcher = resolved ? createPathsMatcher(resolved) : null;
+	}
+	pathsMatcherCache.set(tsconfigPath, matcher);
+	return matcher;
+}
+function createResolver(options) {
+	return enhancedResolve.ResolverFactory.createResolver({
+		conditionNames: options.conditionNames,
+		extensions: options.extensions,
+		fileSystem,
+		...options.mainFields ? { mainFields: options.mainFields } : {},
+		useSyncFileSystemCalls: true
+	});
+}
+function resolveWithResolver(resolver, cwd, request) {
+	try {
+		const resolved = resolver.resolveSync({}, cwd, request);
+		return typeof resolved === "string" ? resolved : null;
+	} catch {
+		return null;
+	}
+}
+function resolveWithTsconfigPaths(context, resolver, cwd, request) {
+	const matcher = getPathsMatcher(context.tsconfigPath);
+	if (!matcher) return null;
+	const matches = matcher(request);
+	if (!matches?.length) return null;
+	for (const match of matches) {
+		const resolved = resolveWithResolver(resolver, cwd, path.isAbsolute(match) ? match : path.resolve(cwd, match));
+		if (resolved) return resolved;
+	}
+	return null;
+}
+function findFileRecursive(cwd, filenames) {
+	let currentDir = cwd;
+	while (true) {
+		for (const filename of filenames) {
+			const candidate = path.resolve(currentDir, filename);
+			if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+		}
+		const parentDir = path.resolve(currentDir, "..");
+		if (parentDir === currentDir) return null;
+		currentDir = parentDir;
+	}
+}
+function readTailwindVersion(packageJsonPath) {
+	if (!packageJsonPath || !fs.existsSync(packageJsonPath)) return null;
+	try {
+		return JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).version ?? null;
+	} catch {
+		return null;
+	}
+}
+function resolveTailwindRuntime(context) {
+	const jsResolver = createResolver({
+		conditionNames: ["node", "import"],
+		extensions: [".mjs", ".js"],
+		mainFields: ["module"]
+	});
+	const cssResolver = createResolver({
+		conditionNames: ["style"],
+		extensions: [".css"],
+		mainFields: ["style"]
+	});
+	const packageJsonPath = resolveWithResolver(jsResolver, context.cwd, "tailwindcss/package.json") ?? resolveWithTsconfigPaths(context, jsResolver, context.cwd, "tailwindcss/package.json");
+	const installationPath = packageJsonPath ? path.dirname(packageJsonPath) : null;
+	const cssEntryPath = resolveWithResolver(cssResolver, context.cwd, "tailwindcss") ?? resolveWithTsconfigPaths(context, cssResolver, context.cwd, "tailwindcss");
+	return {
+		configPath: findFileRecursive(context.cwd, TAILWIND_CONFIG_FILENAMES),
+		cssEntryPath,
+		installationPath,
+		packageJsonPath,
+		version: readTailwindVersion(packageJsonPath)
+	};
+}
+function detectInstalledTailwindVersion(context) {
+	const version = resolveTailwindRuntime(context).version;
+	if (!version) return "unknown";
+	if (version.startsWith("4.")) return 4;
+	if (version.startsWith("3.")) return 3;
+	return "unknown";
+}
+//#endregion
+export { analyzeTailwindCss, collectApplyCandidates, collectImportDirectives, collectThemeCalls, collectUtilitySelectors, detectInstalledTailwindVersion, detectTailwindVersion, parseTailwindCss, resolveTailwindRuntime };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "postcss-tailwindcss",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "PostCSS AST utilities for analyzing Tailwind CSS syntax",
+  "author": "ice breaker <1324318532@qq.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sonofmagic/dev-configs.git",
+    "directory": "packages/postcss-tailwindcss"
+  },
+  "bugs": {
+    "url": "https://github.com/sonofmagic/dev-configs/issues"
+  },
+  "keywords": [
+    "dev-configs",
+    "icebreakers",
+    "postcss",
+    "tailwindcss"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "README.md",
+    "README.zh.md",
+    "dist"
+  ],
+  "dependencies": {
+    "enhanced-resolve": "^5.20.0",
+    "get-tsconfig": "^4.13.6",
+    "postcss": "^8.5.6",
+    "postcss-selector-parser": "^7.1.0",
+    "postcss-value-parser": "^4.2.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "dev": "tsdown --watch --sourcemap",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:dev": "vitest",
+    "release": "pnpm publish",
+    "sync": "cnpm sync postcss-tailwindcss",
+    "typecheck": "tsc --noEmit"
+  }
+}