tailwindcss-patch 9.0.0 → 9.1.0

package/dist/validate-4FCU-Ql3.mjs

@@ -0,0 +1,3525 @@
+import { createRequire } from "node:module";
+import process from "node:process";
+import fs from "fs-extra";
+import { getPackageInfoSync } from "local-pkg";
+import path from "pathe";
+import { coerce } from "semver";
+import { createHash } from "node:crypto";
+import { createConsola } from "consola";
+import path$1 from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { promises } from "node:fs";
+import postcss from "postcss";
+import * as t from "@babel/types";
+import generate from "@babel/generator";
+import _babelTraverse from "@babel/traverse";
+import { parse, parse as parse$1 } from "@babel/parser";
+import { loadConfig } from "tailwindcss-config";
+//#region package.json
+var version = "9.1.0";
+//#endregion
+//#region src/constants.ts
+const pkgName = "tailwindcss-patch";
+const pkgVersion = version;
+//#endregion
+//#region src/cache/context.ts
+const DEFAULT_TAILWIND_CONFIG_FILES = [
+	"tailwind.config.js",
+	"tailwind.config.cjs",
+	"tailwind.config.mjs",
+	"tailwind.config.ts",
+	"tailwind.config.cts",
+	"tailwind.config.mts"
+];
+function normalizePathname(value) {
+	return path.normalize(value).replaceAll("\\", "/");
+}
+function resolveRealpathSyncSafe(value) {
+	const resolved = path.resolve(value);
+	try {
+		return normalizePathname(fs.realpathSync(resolved));
+	} catch {
+		return normalizePathname(resolved);
+	}
+}
+function resolveFileMtimeMsSync(value) {
+	if (!value) return;
+	try {
+		const stat = fs.statSync(value);
+		if (!stat.isFile()) return;
+		return stat.mtimeMs;
+	} catch {
+		return;
+	}
+}
+function resolveTailwindConfigPath(options, majorVersion) {
+	const tailwind = options.tailwind;
+	const baseDir = tailwind.cwd ?? options.projectRoot;
+	const configured = (() => {
+		if (majorVersion === 2 && tailwind.v2?.config) return tailwind.v2.config;
+		if (majorVersion === 3 && tailwind.v3?.config) return tailwind.v3.config;
+		return tailwind.config;
+	})();
+	if (configured) {
+		const absolute = path.isAbsolute(configured) ? configured : path.resolve(baseDir, configured);
+		if (fs.pathExistsSync(absolute)) return resolveRealpathSyncSafe(absolute);
+	}
+	for (const candidate of DEFAULT_TAILWIND_CONFIG_FILES) {
+		const absolute = path.resolve(baseDir, candidate);
+		if (fs.pathExistsSync(absolute)) return resolveRealpathSyncSafe(absolute);
+	}
+}
+function stableSerialize(input) {
+	if (input === null) return "null";
+	if (typeof input === "string") return JSON.stringify(input);
+	if (typeof input === "number" || typeof input === "boolean") return JSON.stringify(input);
+	if (Array.isArray(input)) return `[${input.map((item) => stableSerialize(item)).join(",")}]`;
+	if (typeof input === "object") return `{${Object.entries(input).filter(([, value]) => value !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${JSON.stringify(key)}:${stableSerialize(value)}`).join(",")}}`;
+	return JSON.stringify(String(input));
+}
+function hash(input) {
+	return createHash("sha256").update(input).digest("hex");
+}
+function toFingerprintOptions(normalized) {
+	return {
+		overwrite: normalized.overwrite,
+		output: {
+			removeUniversalSelector: normalized.output.removeUniversalSelector,
+			format: normalized.output.format
+		},
+		features: normalized.features,
+		tailwind: {
+			packageName: normalized.tailwind.packageName,
+			cwd: normalized.tailwind.cwd,
+			config: normalized.tailwind.config,
+			postcssPlugin: normalized.tailwind.postcssPlugin,
+			versionHint: normalized.tailwind.versionHint,
+			v2: normalized.tailwind.v2,
+			v3: normalized.tailwind.v3,
+			v4: normalized.tailwind.v4
+		}
+	};
+}
+function createCacheContextDescriptor(options, packageInfo, majorVersion) {
+	const projectRootRealpath = resolveRealpathSyncSafe(options.projectRoot);
+	const processCwdRealpath = resolveRealpathSyncSafe(process.cwd());
+	const cacheCwdRealpath = resolveRealpathSyncSafe(options.cache.cwd);
+	const tailwindPackageRootRealpath = resolveRealpathSyncSafe(packageInfo.rootPath);
+	const tailwindConfigPath = resolveTailwindConfigPath(options, majorVersion);
+	const tailwindConfigMtimeMs = resolveFileMtimeMsSync(tailwindConfigPath);
+	const optionsHash = hash(stableSerialize(toFingerprintOptions(options)));
+	const metadata = {
+		fingerprintVersion: 1,
+		projectRootRealpath,
+		processCwdRealpath,
+		cacheCwdRealpath,
+		...tailwindConfigPath === void 0 ? {} : { tailwindConfigPath },
+		...tailwindConfigMtimeMs === void 0 ? {} : { tailwindConfigMtimeMs },
+		tailwindPackageRootRealpath,
+		tailwindPackageVersion: packageInfo.version ?? "unknown",
+		patcherVersion: pkgVersion,
+		majorVersion,
+		optionsHash
+	};
+	return {
+		fingerprint: hash(stableSerialize(metadata)),
+		metadata
+	};
+}
+function explainContextMismatch(current, cached) {
+	const reasons = [];
+	if (current.projectRootRealpath !== cached.projectRootRealpath) reasons.push(`project-root changed: ${cached.projectRootRealpath} -> ${current.projectRootRealpath}`);
+	if (current.processCwdRealpath !== cached.processCwdRealpath) reasons.push(`process-cwd changed: ${cached.processCwdRealpath} -> ${current.processCwdRealpath}`);
+	if (current.cacheCwdRealpath !== cached.cacheCwdRealpath) reasons.push(`cache-cwd changed: ${cached.cacheCwdRealpath} -> ${current.cacheCwdRealpath}`);
+	if ((current.tailwindConfigPath ?? "") !== (cached.tailwindConfigPath ?? "")) reasons.push(`tailwind-config path changed: ${cached.tailwindConfigPath ?? "<none>"} -> ${current.tailwindConfigPath ?? "<none>"}`);
+	if ((current.tailwindConfigMtimeMs ?? -1) !== (cached.tailwindConfigMtimeMs ?? -1)) reasons.push("tailwind-config mtime changed");
+	if (current.tailwindPackageRootRealpath !== cached.tailwindPackageRootRealpath) reasons.push(`tailwind-package root changed: ${cached.tailwindPackageRootRealpath} -> ${current.tailwindPackageRootRealpath}`);
+	if (current.tailwindPackageVersion !== cached.tailwindPackageVersion) reasons.push(`tailwind-package version changed: ${cached.tailwindPackageVersion} -> ${current.tailwindPackageVersion}`);
+	if (current.patcherVersion !== cached.patcherVersion) reasons.push(`patcher version changed: ${cached.patcherVersion} -> ${current.patcherVersion}`);
+	if (current.majorVersion !== cached.majorVersion) reasons.push(`major version changed: ${cached.majorVersion} -> ${current.majorVersion}`);
+	if (current.optionsHash !== cached.optionsHash) reasons.push(`patch options hash changed: ${cached.optionsHash.slice(0, 12)} -> ${current.optionsHash.slice(0, 12)}`);
+	return reasons;
+}
+//#endregion
+//#region src/logger.ts
+const logger = createConsola();
+//#endregion
+//#region src/cache/store.ts
+function isErrnoException(error) {
+	return error instanceof Error && typeof error.code === "string";
+}
+function isAccessDenied(error) {
+	return isErrnoException(error) && Boolean(error.code && [
+		"EPERM",
+		"EBUSY",
+		"EACCES"
+	].includes(error.code));
+}
+function toStringArray(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((item) => typeof item === "string");
+}
+function asObject(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function toReadMeta(meta) {
+	return {
+		...meta,
+		details: [...meta.details]
+	};
+}
+function cloneEntry(entry) {
+	return {
+		context: { ...entry.context },
+		values: [...entry.values],
+		updatedAt: entry.updatedAt
+	};
+}
+var CacheStore = class {
+	driver;
+	lockPath;
+	memoryCache = null;
+	memoryIndex = null;
+	lastReadMeta = {
+		hit: false,
+		reason: "context-not-found",
+		details: []
+	};
+	constructor(options, context) {
+		this.options = options;
+		this.context = context;
+		this.driver = options.driver ?? "file";
+		this.lockPath = `${this.options.path}.lock`;
+	}
+	isContextAware() {
+		return this.context !== void 0;
+	}
+	createEmptyIndex() {
+		return {
+			schemaVersion: 2,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			contexts: {}
+		};
+	}
+	async ensureDir() {
+		await fs.ensureDir(this.options.dir);
+	}
+	ensureDirSync() {
+		fs.ensureDirSync(this.options.dir);
+	}
+	createTempPath() {
+		const uniqueSuffix = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+		return `${this.options.path}.${uniqueSuffix}.tmp`;
+	}
+	async replaceCacheFile(tempPath) {
+		try {
+			await fs.rename(tempPath, this.options.path);
+			return true;
+		} catch (error) {
+			if (isErrnoException(error) && (error.code === "EEXIST" || error.code === "EPERM")) {
+				try {
+					await fs.remove(this.options.path);
+				} catch (removeError) {
+					if (isAccessDenied(removeError)) {
+						logger.debug("Tailwind class cache locked or read-only, skipping update.", removeError);
+						return false;
+					}
+					if (!isErrnoException(removeError) || removeError.code !== "ENOENT") throw removeError;
+				}
+				await fs.rename(tempPath, this.options.path);
+				return true;
+			}
+			throw error;
+		}
+	}
+	replaceCacheFileSync(tempPath) {
+		try {
+			fs.renameSync(tempPath, this.options.path);
+			return true;
+		} catch (error) {
+			if (isErrnoException(error) && (error.code === "EEXIST" || error.code === "EPERM")) {
+				try {
+					fs.removeSync(this.options.path);
+				} catch (removeError) {
+					if (isAccessDenied(removeError)) {
+						logger.debug("Tailwind class cache locked or read-only, skipping update.", removeError);
+						return false;
+					}
+					if (!isErrnoException(removeError) || removeError.code !== "ENOENT") throw removeError;
+				}
+				fs.renameSync(tempPath, this.options.path);
+				return true;
+			}
+			throw error;
+		}
+	}
+	async cleanupTempFile(tempPath) {
+		try {
+			await fs.remove(tempPath);
+		} catch {}
+	}
+	cleanupTempFileSync(tempPath) {
+		try {
+			fs.removeSync(tempPath);
+		} catch {}
+	}
+	async delay(ms) {
+		await new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	async acquireLock() {
+		await fs.ensureDir(this.options.dir);
+		const maxAttempts = 40;
+		for (let attempt = 0; attempt < maxAttempts; attempt++) try {
+			await fs.writeFile(this.lockPath, `${process.pid}\n${Date.now()}`, { flag: "wx" });
+			return true;
+		} catch (error) {
+			if (!isErrnoException(error) || error.code !== "EEXIST") {
+				logger.debug("Unable to acquire cache lock.", error);
+				return false;
+			}
+			try {
+				const stat = await fs.stat(this.lockPath);
+				if (Date.now() - stat.mtimeMs > 3e4) {
+					await fs.remove(this.lockPath);
+					continue;
+				}
+			} catch {}
+			await this.delay(25);
+		}
+		logger.debug("Timed out while waiting for cache lock; skipping cache mutation.");
+		return false;
+	}
+	releaseLockSyncOrAsync(sync) {
+		if (sync) {
+			try {
+				fs.removeSync(this.lockPath);
+			} catch {}
+			return;
+		}
+		return fs.remove(this.lockPath).catch(() => void 0);
+	}
+	acquireLockSync() {
+		fs.ensureDirSync(this.options.dir);
+		const maxAttempts = 40;
+		for (let attempt = 0; attempt < maxAttempts; attempt++) try {
+			fs.writeFileSync(this.lockPath, `${process.pid}\n${Date.now()}`, { flag: "wx" });
+			return true;
+		} catch (error) {
+			if (!isErrnoException(error) || error.code !== "EEXIST") {
+				logger.debug("Unable to acquire cache lock.", error);
+				return false;
+			}
+			try {
+				const stat = fs.statSync(this.lockPath);
+				if (Date.now() - stat.mtimeMs > 3e4) {
+					fs.removeSync(this.lockPath);
+					continue;
+				}
+			} catch {}
+			const start = Date.now();
+			while (Date.now() - start < 25);
+		}
+		logger.debug("Timed out while waiting for cache lock; skipping cache mutation.");
+		return false;
+	}
+	async withFileLock(fn) {
+		if (!await this.acquireLock()) return;
+		try {
+			return await fn();
+		} finally {
+			await this.releaseLockSyncOrAsync(false);
+		}
+	}
+	withFileLockSync(fn) {
+		if (!this.acquireLockSync()) return;
+		try {
+			return fn();
+		} finally {
+			this.releaseLockSyncOrAsync(true);
+		}
+	}
+	normalizeContextEntry(value) {
+		const record = asObject(value);
+		if (!record) return;
+		const values = toStringArray(record["values"]);
+		if (values.length === 0) return;
+		const contextRecord = asObject(record["context"]);
+		if (!contextRecord) return;
+		const { fingerprintVersion, projectRootRealpath, processCwdRealpath, cacheCwdRealpath, tailwindConfigPath, tailwindConfigMtimeMs, tailwindPackageRootRealpath, tailwindPackageVersion, patcherVersion, majorVersion, optionsHash } = contextRecord;
+		if (fingerprintVersion !== 1 || typeof projectRootRealpath !== "string" || typeof processCwdRealpath !== "string" || typeof cacheCwdRealpath !== "string" || typeof tailwindPackageRootRealpath !== "string" || typeof tailwindPackageVersion !== "string" || typeof patcherVersion !== "string" || majorVersion !== 2 && majorVersion !== 3 && majorVersion !== 4 || typeof optionsHash !== "string") return;
+		return {
+			context: {
+				fingerprintVersion,
+				projectRootRealpath,
+				processCwdRealpath,
+				cacheCwdRealpath,
+				...typeof tailwindConfigPath === "string" ? { tailwindConfigPath } : {},
+				...typeof tailwindConfigMtimeMs === "number" ? { tailwindConfigMtimeMs } : {},
+				tailwindPackageRootRealpath,
+				tailwindPackageVersion,
+				patcherVersion,
+				majorVersion,
+				optionsHash
+			},
+			values,
+			updatedAt: typeof record["updatedAt"] === "string" ? record["updatedAt"] : (/* @__PURE__ */ new Date(0)).toISOString()
+		};
+	}
+	normalizeIndexFile(payload) {
+		if (Array.isArray(payload)) return {
+			kind: "legacy",
+			data: toStringArray(payload)
+		};
+		const record = asObject(payload);
+		if (!record) return { kind: "invalid" };
+		if (record["schemaVersion"] !== 2) return { kind: "invalid" };
+		const contextsRecord = asObject(record["contexts"]);
+		if (!contextsRecord) return { kind: "invalid" };
+		const contexts = {};
+		for (const [fingerprint, value] of Object.entries(contextsRecord)) {
+			if (typeof fingerprint !== "string" || !fingerprint) continue;
+			const entry = this.normalizeContextEntry(value);
+			if (!entry) continue;
+			contexts[fingerprint] = entry;
+		}
+		return {
+			kind: "v2",
+			data: {
+				schemaVersion: 2,
+				updatedAt: typeof record["updatedAt"] === "string" ? record["updatedAt"] : (/* @__PURE__ */ new Date(0)).toISOString(),
+				contexts
+			}
+		};
+	}
+	async readParsedCacheFile(cleanupInvalid) {
+		try {
+			if (!await fs.pathExists(this.options.path)) return { kind: "empty" };
+			const payload = await fs.readJSON(this.options.path);
+			const normalized = this.normalizeIndexFile(payload);
+			if (normalized.kind !== "invalid") return normalized;
+			if (cleanupInvalid) {
+				logger.warn("Unable to read Tailwind class cache index, removing invalid file.");
+				await fs.remove(this.options.path);
+			}
+			return { kind: "invalid" };
+		} catch (error) {
+			if (isErrnoException(error) && error.code === "ENOENT") return { kind: "empty" };
+			logger.warn("Unable to read Tailwind class cache index, removing invalid file.", error);
+			if (cleanupInvalid) try {
+				await fs.remove(this.options.path);
+			} catch (cleanupError) {
+				logger.error("Failed to clean up invalid cache file", cleanupError);
+			}
+			return { kind: "invalid" };
+		}
+	}
+	readParsedCacheFileSync(cleanupInvalid) {
+		try {
+			if (!fs.pathExistsSync(this.options.path)) return { kind: "empty" };
+			const payload = fs.readJSONSync(this.options.path);
+			const normalized = this.normalizeIndexFile(payload);
+			if (normalized.kind !== "invalid") return normalized;
+			if (cleanupInvalid) {
+				logger.warn("Unable to read Tailwind class cache index, removing invalid file.");
+				fs.removeSync(this.options.path);
+			}
+			return { kind: "invalid" };
+		} catch (error) {
+			if (isErrnoException(error) && error.code === "ENOENT") return { kind: "empty" };
+			logger.warn("Unable to read Tailwind class cache index, removing invalid file.", error);
+			if (cleanupInvalid) try {
+				fs.removeSync(this.options.path);
+			} catch (cleanupError) {
+				logger.error("Failed to clean up invalid cache file", cleanupError);
+			}
+			return { kind: "invalid" };
+		}
+	}
+	findProjectMatch(index) {
+		if (!this.context) return;
+		const current = this.context.metadata.projectRootRealpath;
+		return Object.entries(index.contexts).find(([, entry]) => entry.context.projectRootRealpath === current);
+	}
+	async writeIndexFile(index) {
+		const tempPath = this.createTempPath();
+		try {
+			await this.ensureDir();
+			await fs.writeJSON(tempPath, index);
+			if (await this.replaceCacheFile(tempPath)) return this.options.path;
+			await this.cleanupTempFile(tempPath);
+			return;
+		} catch (error) {
+			await this.cleanupTempFile(tempPath);
+			logger.error("Unable to persist Tailwind class cache", error);
+			return;
+		}
+	}
+	writeIndexFileSync(index) {
+		const tempPath = this.createTempPath();
+		try {
+			this.ensureDirSync();
+			fs.writeJSONSync(tempPath, index);
+			if (this.replaceCacheFileSync(tempPath)) return this.options.path;
+			this.cleanupTempFileSync(tempPath);
+			return;
+		} catch (error) {
+			this.cleanupTempFileSync(tempPath);
+			logger.error("Unable to persist Tailwind class cache", error);
+			return;
+		}
+	}
+	async write(data) {
+		if (!this.options.enabled) return;
+		if (this.driver === "noop") return;
+		if (this.driver === "memory") {
+			if (!this.isContextAware()) {
+				this.memoryCache = new Set(data);
+				return "memory";
+			}
+			const index = this.memoryIndex ?? this.createEmptyIndex();
+			if (!this.context) return "memory";
+			index.contexts[this.context.fingerprint] = {
+				context: { ...this.context.metadata },
+				values: Array.from(data),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			this.memoryIndex = index;
+			return "memory";
+		}
+		if (!this.isContextAware()) {
+			const tempPath = this.createTempPath();
+			try {
+				await this.ensureDir();
+				await fs.writeJSON(tempPath, Array.from(data));
+				if (await this.replaceCacheFile(tempPath)) return this.options.path;
+				await this.cleanupTempFile(tempPath);
+				return;
+			} catch (error) {
+				await this.cleanupTempFile(tempPath);
+				logger.error("Unable to persist Tailwind class cache", error);
+				return;
+			}
+		}
+		return await this.withFileLock(async () => {
+			const parsed = await this.readParsedCacheFile(false);
+			const index = parsed.kind === "v2" ? parsed.data : this.createEmptyIndex();
+			if (this.context) index.contexts[this.context.fingerprint] = {
+				context: { ...this.context.metadata },
+				values: Array.from(data),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			return this.writeIndexFile(index);
+		});
+	}
+	writeSync(data) {
+		if (!this.options.enabled) return;
+		if (this.driver === "noop") return;
+		if (this.driver === "memory") {
+			if (!this.isContextAware()) {
+				this.memoryCache = new Set(data);
+				return "memory";
+			}
+			const index = this.memoryIndex ?? this.createEmptyIndex();
+			if (!this.context) return "memory";
+			index.contexts[this.context.fingerprint] = {
+				context: { ...this.context.metadata },
+				values: Array.from(data),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			this.memoryIndex = index;
+			return "memory";
+		}
+		if (!this.isContextAware()) {
+			const tempPath = this.createTempPath();
+			try {
+				this.ensureDirSync();
+				fs.writeJSONSync(tempPath, Array.from(data));
+				if (this.replaceCacheFileSync(tempPath)) return this.options.path;
+				this.cleanupTempFileSync(tempPath);
+				return;
+			} catch (error) {
+				this.cleanupTempFileSync(tempPath);
+				logger.error("Unable to persist Tailwind class cache", error);
+				return;
+			}
+		}
+		return this.withFileLockSync(() => {
+			const parsed = this.readParsedCacheFileSync(false);
+			const index = parsed.kind === "v2" ? parsed.data : this.createEmptyIndex();
+			if (this.context) index.contexts[this.context.fingerprint] = {
+				context: { ...this.context.metadata },
+				values: Array.from(data),
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			return this.writeIndexFileSync(index);
+		});
+	}
+	async readWithMeta() {
+		if (!this.options.enabled) return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "cache-disabled",
+				details: ["cache disabled"]
+			}
+		};
+		if (this.driver === "noop") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "noop-driver",
+				details: ["cache driver is noop"]
+			}
+		};
+		if (this.driver === "memory") {
+			if (!this.isContextAware()) {
+				const cache = new Set(this.memoryCache ?? []);
+				return {
+					data: cache,
+					meta: {
+						hit: cache.size > 0,
+						reason: cache.size > 0 ? "hit" : "context-not-found",
+						details: cache.size > 0 ? ["memory cache hit"] : ["memory cache miss"]
+					}
+				};
+			}
+			const index = this.memoryIndex;
+			if (!index || !this.context) return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-not-found",
+					...this.context?.fingerprint === void 0 ? {} : { fingerprint: this.context.fingerprint },
+					schemaVersion: 2,
+					details: ["no in-memory cache index for current context"]
+				}
+			};
+			const entry = index.contexts[this.context.fingerprint];
+			if (entry) return {
+				data: new Set(entry.values),
+				meta: {
+					hit: true,
+					reason: "hit",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: 2,
+					details: ["memory cache hit"]
+				}
+			};
+			const projectMatch = this.findProjectMatch(index);
+			if (projectMatch && this.context) {
+				const [, matchedEntry] = projectMatch;
+				return {
+					data: /* @__PURE__ */ new Set(),
+					meta: {
+						hit: false,
+						reason: "context-mismatch",
+						fingerprint: this.context.fingerprint,
+						schemaVersion: 2,
+						details: explainContextMismatch(this.context.metadata, matchedEntry.context)
+					}
+				};
+			}
+			return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-not-found",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: 2,
+					details: ["context fingerprint not found in memory cache index"]
+				}
+			};
+		}
+		const parsed = await this.readParsedCacheFile(true);
+		if (parsed.kind === "empty") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "file-missing",
+				details: ["cache file not found"]
+			}
+		};
+		if (parsed.kind === "invalid") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "invalid-schema",
+				details: ["cache schema invalid and has been reset"]
+			}
+		};
+		if (!this.isContextAware()) {
+			if (parsed.kind === "legacy") return {
+				data: new Set(parsed.data),
+				meta: {
+					hit: parsed.data.length > 0,
+					reason: parsed.data.length > 0 ? "hit" : "context-not-found",
+					details: ["legacy cache format"]
+				}
+			};
+			const union = Object.values(parsed.data.contexts).flatMap((entry) => entry.values);
+			return {
+				data: new Set(union),
+				meta: {
+					hit: union.length > 0,
+					reason: union.length > 0 ? "hit" : "context-not-found",
+					schemaVersion: parsed.data.schemaVersion,
+					details: ["context-less read merged all cache entries"]
+				}
+			};
+		}
+		if (parsed.kind === "legacy") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "legacy-schema",
+				...this.context?.fingerprint === void 0 ? {} : { fingerprint: this.context.fingerprint },
+				details: ["legacy cache schema detected; rebuilding cache with context fingerprint"]
+			}
+		};
+		if (!this.context) return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "context-not-found",
+				details: ["cache context missing"]
+			}
+		};
+		const entry = parsed.data.contexts[this.context.fingerprint];
+		if (entry) {
+			const mismatchReasons = explainContextMismatch(this.context.metadata, entry.context);
+			if (mismatchReasons.length === 0) return {
+				data: new Set(entry.values),
+				meta: {
+					hit: true,
+					reason: "hit",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: parsed.data.schemaVersion,
+					details: [`context fingerprint ${this.context.fingerprint.slice(0, 12)} matched`]
+				}
+			};
+			return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-mismatch",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: parsed.data.schemaVersion,
+					details: mismatchReasons
+				}
+			};
+		}
+		const projectMatch = this.findProjectMatch(parsed.data);
+		if (projectMatch) {
+			const [matchedFingerprint, matchedEntry] = projectMatch;
+			return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-mismatch",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: parsed.data.schemaVersion,
+					details: [`nearest context fingerprint: ${matchedFingerprint.slice(0, 12)}`, ...explainContextMismatch(this.context.metadata, matchedEntry.context)]
+				}
+			};
+		}
+		return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "context-not-found",
+				fingerprint: this.context.fingerprint,
+				schemaVersion: parsed.data.schemaVersion,
+				details: ["context fingerprint not found in cache index"]
+			}
+		};
+	}
+	readWithMetaSync() {
+		if (!this.options.enabled) return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "cache-disabled",
+				details: ["cache disabled"]
+			}
+		};
+		if (this.driver === "noop") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "noop-driver",
+				details: ["cache driver is noop"]
+			}
+		};
+		if (this.driver === "memory") {
+			if (!this.isContextAware()) {
+				const cache = new Set(this.memoryCache ?? []);
+				return {
+					data: cache,
+					meta: {
+						hit: cache.size > 0,
+						reason: cache.size > 0 ? "hit" : "context-not-found",
+						details: cache.size > 0 ? ["memory cache hit"] : ["memory cache miss"]
+					}
+				};
+			}
+			const index = this.memoryIndex;
+			if (!index || !this.context) return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-not-found",
+					...this.context?.fingerprint === void 0 ? {} : { fingerprint: this.context.fingerprint },
+					schemaVersion: 2,
+					details: ["no in-memory cache index for current context"]
+				}
+			};
+			const entry = index.contexts[this.context.fingerprint];
+			if (entry) return {
+				data: new Set(entry.values),
+				meta: {
+					hit: true,
+					reason: "hit",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: 2,
+					details: ["memory cache hit"]
+				}
+			};
+			const projectMatch = this.findProjectMatch(index);
+			if (projectMatch && this.context) {
+				const [, matchedEntry] = projectMatch;
+				return {
+					data: /* @__PURE__ */ new Set(),
+					meta: {
+						hit: false,
+						reason: "context-mismatch",
+						fingerprint: this.context.fingerprint,
+						schemaVersion: 2,
+						details: explainContextMismatch(this.context.metadata, matchedEntry.context)
+					}
+				};
+			}
+			return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-not-found",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: 2,
+					details: ["context fingerprint not found in memory cache index"]
+				}
+			};
+		}
+		const parsed = this.readParsedCacheFileSync(true);
+		if (parsed.kind === "empty") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "file-missing",
+				details: ["cache file not found"]
+			}
+		};
+		if (parsed.kind === "invalid") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "invalid-schema",
+				details: ["cache schema invalid and has been reset"]
+			}
+		};
+		if (!this.isContextAware()) {
+			if (parsed.kind === "legacy") return {
+				data: new Set(parsed.data),
+				meta: {
+					hit: parsed.data.length > 0,
+					reason: parsed.data.length > 0 ? "hit" : "context-not-found",
+					details: ["legacy cache format"]
+				}
+			};
+			const union = Object.values(parsed.data.contexts).flatMap((entry) => entry.values);
+			return {
+				data: new Set(union),
+				meta: {
+					hit: union.length > 0,
+					reason: union.length > 0 ? "hit" : "context-not-found",
+					schemaVersion: parsed.data.schemaVersion,
+					details: ["context-less read merged all cache entries"]
+				}
+			};
+		}
+		if (parsed.kind === "legacy") return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "legacy-schema",
+				...this.context?.fingerprint === void 0 ? {} : { fingerprint: this.context.fingerprint },
+				details: ["legacy cache schema detected; rebuilding cache with context fingerprint"]
+			}
+		};
+		if (!this.context) return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "context-not-found",
+				details: ["cache context missing"]
+			}
+		};
+		const entry = parsed.data.contexts[this.context.fingerprint];
+		if (entry) {
+			const mismatchReasons = explainContextMismatch(this.context.metadata, entry.context);
+			if (mismatchReasons.length === 0) return {
+				data: new Set(entry.values),
+				meta: {
+					hit: true,
+					reason: "hit",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: parsed.data.schemaVersion,
+					details: [`context fingerprint ${this.context.fingerprint.slice(0, 12)} matched`]
+				}
+			};
+			return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-mismatch",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: parsed.data.schemaVersion,
+					details: mismatchReasons
+				}
+			};
+		}
+		const projectMatch = this.findProjectMatch(parsed.data);
+		if (projectMatch) {
+			const [matchedFingerprint, matchedEntry] = projectMatch;
+			return {
+				data: /* @__PURE__ */ new Set(),
+				meta: {
+					hit: false,
+					reason: "context-mismatch",
+					fingerprint: this.context.fingerprint,
+					schemaVersion: parsed.data.schemaVersion,
+					details: [`nearest context fingerprint: ${matchedFingerprint.slice(0, 12)}`, ...explainContextMismatch(this.context.metadata, matchedEntry.context)]
+				}
+			};
+		}
+		return {
+			data: /* @__PURE__ */ new Set(),
+			meta: {
+				hit: false,
+				reason: "context-not-found",
+				fingerprint: this.context.fingerprint,
+				schemaVersion: parsed.data.schemaVersion,
+				details: ["context fingerprint not found in cache index"]
+			}
+		};
+	}
+	async read() {
+		const result = await this.readWithMeta();
+		this.lastReadMeta = toReadMeta(result.meta);
+		return new Set(result.data);
+	}
+	readSync() {
+		const result = this.readWithMetaSync();
+		this.lastReadMeta = toReadMeta(result.meta);
+		return new Set(result.data);
+	}
+	getLastReadMeta() {
+		return toReadMeta(this.lastReadMeta);
+	}
+	countEntriesFromParsed(parsed) {
+		if (parsed.kind === "legacy") return {
+			contexts: parsed.data.length ? 1 : 0,
+			entries: parsed.data.length
+		};
+		if (parsed.kind === "v2") {
+			const values = Object.values(parsed.data.contexts);
+			return {
+				contexts: values.length,
+				entries: values.reduce((acc, item) => acc + item.values.length, 0)
+			};
+		}
+		return {
+			contexts: 0,
+			entries: 0
+		};
+	}
+	async clear(options) {
+		const scope = options?.scope ?? "current";
+		if (!this.options.enabled || this.driver === "noop") return {
+			scope,
+			filesRemoved: 0,
+			entriesRemoved: 0,
+			contextsRemoved: 0
+		};
+		if (this.driver === "memory") {
+			if (!this.isContextAware() || scope === "all") {
+				const entriesRemoved = this.memoryCache?.size ?? (this.memoryIndex ? this.countEntriesFromParsed({
+					kind: "v2",
+					data: this.memoryIndex
+				}).entries : 0);
+				const contextsRemoved = this.memoryIndex ? Object.keys(this.memoryIndex.contexts).length : this.memoryCache?.size ? 1 : 0;
+				this.memoryCache = null;
+				this.memoryIndex = null;
+				return {
+					scope,
+					filesRemoved: 0,
+					entriesRemoved,
+					contextsRemoved
+				};
+			}
+			if (!this.context || !this.memoryIndex) return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			const entry = this.memoryIndex.contexts[this.context.fingerprint];
+			if (!entry) return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			const entriesRemoved = entry.values.length;
+			delete this.memoryIndex.contexts[this.context.fingerprint];
+			return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved,
+				contextsRemoved: 1
+			};
+		}
+		return await this.withFileLock(async () => {
+			const parsed = await this.readParsedCacheFile(false);
+			if (parsed.kind === "empty") return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			if (!this.isContextAware() || scope === "all") {
+				const counts = this.countEntriesFromParsed(parsed);
+				await fs.remove(this.options.path);
+				return {
+					scope,
+					filesRemoved: 1,
+					entriesRemoved: counts.entries,
+					contextsRemoved: counts.contexts
+				};
+			}
+			if (parsed.kind !== "v2" || !this.context) {
+				const counts = this.countEntriesFromParsed(parsed);
+				await fs.remove(this.options.path);
+				return {
+					scope,
+					filesRemoved: 1,
+					entriesRemoved: counts.entries,
+					contextsRemoved: counts.contexts
+				};
+			}
+			const entry = parsed.data.contexts[this.context.fingerprint];
+			if (!entry) return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			const entriesRemoved = entry.values.length;
+			delete parsed.data.contexts[this.context.fingerprint];
+			if (Object.keys(parsed.data.contexts).length === 0) {
+				await fs.remove(this.options.path);
+				return {
+					scope,
+					filesRemoved: 1,
+					entriesRemoved,
+					contextsRemoved: 1
+				};
+			}
+			parsed.data.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			await this.writeIndexFile(parsed.data);
+			return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved,
+				contextsRemoved: 1
+			};
+		}) ?? {
+			scope,
+			filesRemoved: 0,
+			entriesRemoved: 0,
+			contextsRemoved: 0
+		};
+	}
+	clearSync(options) {
+		const scope = options?.scope ?? "current";
+		if (!this.options.enabled || this.driver === "noop") return {
+			scope,
+			filesRemoved: 0,
+			entriesRemoved: 0,
+			contextsRemoved: 0
+		};
+		if (this.driver === "memory") {
+			if (!this.isContextAware() || scope === "all") {
+				const entriesRemoved = this.memoryCache?.size ?? (this.memoryIndex ? this.countEntriesFromParsed({
+					kind: "v2",
+					data: this.memoryIndex
+				}).entries : 0);
+				const contextsRemoved = this.memoryIndex ? Object.keys(this.memoryIndex.contexts).length : this.memoryCache?.size ? 1 : 0;
+				this.memoryCache = null;
+				this.memoryIndex = null;
+				return {
+					scope,
+					filesRemoved: 0,
+					entriesRemoved,
+					contextsRemoved
+				};
+			}
+			if (!this.context || !this.memoryIndex) return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			const entry = this.memoryIndex.contexts[this.context.fingerprint];
+			if (!entry) return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			const entriesRemoved = entry.values.length;
+			delete this.memoryIndex.contexts[this.context.fingerprint];
+			return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved,
+				contextsRemoved: 1
+			};
+		}
+		return this.withFileLockSync(() => {
+			const parsed = this.readParsedCacheFileSync(false);
+			if (parsed.kind === "empty") return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			if (!this.isContextAware() || scope === "all") {
+				const counts = this.countEntriesFromParsed(parsed);
+				fs.removeSync(this.options.path);
+				return {
+					scope,
+					filesRemoved: 1,
+					entriesRemoved: counts.entries,
+					contextsRemoved: counts.contexts
+				};
+			}
+			if (parsed.kind !== "v2" || !this.context) {
+				const counts = this.countEntriesFromParsed(parsed);
+				fs.removeSync(this.options.path);
+				return {
+					scope,
+					filesRemoved: 1,
+					entriesRemoved: counts.entries,
+					contextsRemoved: counts.contexts
+				};
+			}
+			const entry = parsed.data.contexts[this.context.fingerprint];
+			if (!entry) return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved: 0,
+				contextsRemoved: 0
+			};
+			const entriesRemoved = entry.values.length;
+			delete parsed.data.contexts[this.context.fingerprint];
+			if (Object.keys(parsed.data.contexts).length === 0) {
+				fs.removeSync(this.options.path);
+				return {
+					scope,
+					filesRemoved: 1,
+					entriesRemoved,
+					contextsRemoved: 1
+				};
+			}
+			parsed.data.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			this.writeIndexFileSync(parsed.data);
+			return {
+				scope,
+				filesRemoved: 0,
+				entriesRemoved,
+				contextsRemoved: 1
+			};
+		}) ?? {
+			scope,
+			filesRemoved: 0,
+			entriesRemoved: 0,
+			contextsRemoved: 0
+		};
+	}
+	readIndexSnapshot() {
+		if (this.driver === "memory") return this.memoryIndex ? {
+			...this.memoryIndex,
+			contexts: Object.fromEntries(Object.entries(this.memoryIndex.contexts).map(([key, value]) => [key, cloneEntry(value)]))
+		} : void 0;
+		const parsed = this.readParsedCacheFileSync(false);
+		if (parsed.kind !== "v2") return;
+		return {
+			...parsed.data,
+			contexts: Object.fromEntries(Object.entries(parsed.data.contexts).map(([key, value]) => [key, cloneEntry(value)]))
+		};
+	}
+};
+//#endregion
+//#region src/options/legacy.ts
+const deprecatedRegistryMapping = {
+	output: "extract",
+	tailwind: "tailwindcss"
+};
+const deprecatedTailwindMapping = {
+	package: "packageName",
+	legacy: "v2",
+	classic: "v3",
+	next: "v4"
+};
+function assertNoDeprecatedRegistryOptions(registry) {
+	const usedRegistryKeys = Object.keys(deprecatedRegistryMapping).filter((key) => Object.hasOwn(registry, key));
+	if (usedRegistryKeys.length > 0) {
+		const mapping = usedRegistryKeys.map((key) => `${key} -> ${deprecatedRegistryMapping[key]}`).join(", ");
+		throw new Error(`Legacy registry fields are no longer supported: ${usedRegistryKeys.join(", ")}. Use the modern fields instead: ${mapping}.`);
+	}
+	const tailwind = registry.tailwindcss;
+	if (!tailwind) return;
+	const usedTailwindKeys = Object.keys(deprecatedTailwindMapping).filter((key) => Object.hasOwn(tailwind, key));
+	if (usedTailwindKeys.length > 0) {
+		const mapping = usedTailwindKeys.map((key) => `${key} -> tailwindcss.${deprecatedTailwindMapping[key]}`).join(", ");
+		throw new Error(`Legacy "registry.tailwindcss" fields are no longer supported: ${usedTailwindKeys.join(", ")}. Use the modern fields instead: ${mapping}.`);
+	}
+}
+function fromUnifiedConfig(registry) {
+	if (!registry) return {};
+	assertNoDeprecatedRegistryOptions(registry);
+	const extract = registry.extract ? {
+		...registry.extract.write === void 0 ? {} : { write: registry.extract.write },
+		...registry.extract.file === void 0 ? {} : { file: registry.extract.file },
+		...registry.extract.format === void 0 ? {} : { format: registry.extract.format },
+		...registry.extract.pretty === void 0 ? {} : { pretty: registry.extract.pretty },
+		...registry.extract.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: registry.extract.removeUniversalSelector }
+	} : void 0;
+	const tailwindcss = registry.tailwindcss ? {
+		...registry.tailwindcss.version === void 0 ? {} : { version: registry.tailwindcss.version },
+		...registry.tailwindcss.packageName === void 0 ? {} : { packageName: registry.tailwindcss.packageName },
+		...registry.tailwindcss.resolve === void 0 ? {} : { resolve: registry.tailwindcss.resolve },
+		...registry.tailwindcss.config === void 0 ? {} : { config: registry.tailwindcss.config },
+		...registry.tailwindcss.cwd === void 0 ? {} : { cwd: registry.tailwindcss.cwd },
+		...registry.tailwindcss.v2 === void 0 ? {} : { v2: registry.tailwindcss.v2 },
+		...registry.tailwindcss.v3 === void 0 ? {} : { v3: registry.tailwindcss.v3 },
+		...registry.tailwindcss.v4 === void 0 ? {} : { v4: registry.tailwindcss.v4 }
+	} : void 0;
+	const apply = registry.apply ? {
+		...registry.apply.overwrite === void 0 ? {} : { overwrite: registry.apply.overwrite },
+		...registry.apply.exposeContext === void 0 ? {} : { exposeContext: registry.apply.exposeContext },
+		...registry.apply.extendLengthUnits === void 0 ? {} : { extendLengthUnits: registry.apply.extendLengthUnits }
+	} : void 0;
+	return {
+		...registry.projectRoot === void 0 ? {} : { projectRoot: registry.projectRoot },
+		...apply === void 0 ? {} : { apply },
+		...registry.cache === void 0 ? {} : { cache: registry.cache },
+		...registry.filter === void 0 ? {} : { filter: registry.filter },
+		...extract === void 0 ? {} : { extract },
+		...tailwindcss === void 0 ? {} : { tailwindcss }
+	};
+}
+//#endregion
+//#region src/options/normalize.ts
+function resolveRealpathSafe(value) {
+	const resolved = path.resolve(value);
+	try {
+		return path.normalize(fs.realpathSync(resolved));
+	} catch {
+		return path.normalize(resolved);
+	}
+}
+function toPrettyValue(value) {
+	if (typeof value === "number") return value > 0 ? value : false;
+	if (value === true) return 2;
+	return false;
+}
+function normalizeCacheDriver(driver) {
+	if (driver === "memory" || driver === "noop") return driver;
+	return "file";
+}
+function normalizeCacheOptions(cache, projectRoot) {
+	let enabled = false;
+	let cwd = resolveRealpathSafe(projectRoot);
+	let dir = path.resolve(cwd, "node_modules/.cache", pkgName);
+	let file = "class-cache.json";
+	let strategy = "merge";
+	let driver = "file";
+	if (typeof cache === "boolean") enabled = cache;
+	else if (typeof cache === "object" && cache) {
+		enabled = cache.enabled ?? true;
+		cwd = cache.cwd ? resolveRealpathSafe(cache.cwd) : cwd;
+		dir = cache.dir ? path.resolve(cache.dir) : path.resolve(cwd, "node_modules/.cache", pkgName);
+		file = cache.file ?? file;
+		strategy = cache.strategy ?? strategy;
+		driver = normalizeCacheDriver(cache.driver);
+	}
+	const filename = path.resolve(dir, file);
+	return {
+		enabled,
+		cwd,
+		dir,
+		file,
+		path: filename,
+		strategy,
+		driver
+	};
+}
+function normalizeOutputOptions(output) {
+	return {
+		enabled: output?.write ?? true,
+		file: output?.file ?? ".tw-patch/tw-class-list.json",
+		format: output?.format ?? "json",
+		pretty: toPrettyValue(output?.pretty ?? true),
+		removeUniversalSelector: output?.removeUniversalSelector ?? true
+	};
+}
+function normalizeExposeContextOptions(exposeContext) {
+	if (exposeContext === false) return {
+		enabled: false,
+		refProperty: "contextRef"
+	};
+	if (typeof exposeContext === "object" && exposeContext) return {
+		enabled: true,
+		refProperty: exposeContext.refProperty ?? "contextRef"
+	};
+	return {
+		enabled: true,
+		refProperty: "contextRef"
+	};
+}
+function normalizeExtendLengthUnitsOptions(extend) {
+	if (extend === false || extend === void 0) return null;
+	if (extend.enabled === false) return null;
+	const base = {
+		units: ["rpx"],
+		overwrite: true
+	};
+	return {
+		...base,
+		...extend,
+		enabled: extend.enabled ?? true,
+		units: extend.units ?? base.units,
+		overwrite: extend.overwrite ?? base.overwrite
+	};
+}
+function normalizeTailwindV4Options(v4, fallbackBase) {
+	const configuredBase = v4?.base ? path.resolve(v4.base) : void 0;
+	const base = configuredBase ?? fallbackBase;
+	const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => path.resolve(entry)) : [];
+	const userSources = v4?.sources;
+	const hasUserDefinedSources = Boolean(userSources?.length);
+	const sources = hasUserDefinedSources ? userSources : [{
+		base: fallbackBase,
+		pattern: "**/*",
+		negated: false
+	}];
+	return {
+		base,
+		...configuredBase === void 0 ? {} : { configuredBase },
+		...v4?.css === void 0 ? {} : { css: v4.css },
+		cssEntries,
+		sources,
+		hasUserDefinedSources
+	};
+}
+function normalizeTailwindOptions(tailwind, projectRoot, shouldDefaultResolveFromCwd) {
+	const packageName = tailwind?.packageName ?? "tailwindcss";
+	const versionHint = tailwind?.version;
+	const cwd = tailwind?.cwd ?? projectRoot;
+	const resolve = tailwind?.resolve ?? (shouldDefaultResolveFromCwd ? { paths: [cwd] } : void 0);
+	const config = tailwind?.config;
+	const postcssPlugin = tailwind?.postcssPlugin;
+	const v4 = normalizeTailwindV4Options(tailwind?.v4, cwd);
+	return {
+		packageName,
+		cwd,
+		...versionHint === void 0 ? {} : { versionHint },
+		...resolve === void 0 ? {} : { resolve },
+		...config === void 0 ? {} : { config },
+		...postcssPlugin === void 0 ? {} : { postcssPlugin },
+		...tailwind?.v2 === void 0 ? {} : { v2: tailwind.v2 },
+		...tailwind?.v3 === void 0 ? {} : { v3: tailwind.v3 },
+		v4
+	};
+}
+const deprecatedOptionMapping = {
+	cwd: "projectRoot",
+	overwrite: "apply.overwrite",
+	tailwind: "tailwindcss",
+	features: "apply",
+	output: "extract"
+};
+function assertNoDeprecatedOptions(options) {
+	const used = Object.keys(deprecatedOptionMapping).filter((key) => Object.hasOwn(options, key));
+	if (used.length === 0) return;
+	const mapping = used.map((key) => `${key} -> ${deprecatedOptionMapping[key]}`).join(", ");
+	throw new Error(`Legacy TailwindcssPatcher options are no longer supported: ${used.join(", ")}. Use the modern fields instead: ${mapping}.`);
+}
+function normalizeOptions(options = {}) {
+	assertNoDeprecatedOptions(options);
+	const projectRoot = resolveRealpathSafe(options.projectRoot ? path.resolve(options.projectRoot) : process.cwd());
+	const overwrite = options.apply?.overwrite ?? true;
+	const output = normalizeOutputOptions(options.extract);
+	const cache = normalizeCacheOptions(options.cache, projectRoot);
+	const tailwind = normalizeTailwindOptions(options.tailwindcss, projectRoot, options.projectRoot !== void 0 || options.tailwindcss?.cwd !== void 0);
+	const exposeContext = normalizeExposeContextOptions(options.apply?.exposeContext);
+	const extendLengthUnits = normalizeExtendLengthUnitsOptions(options.apply?.extendLengthUnits);
+	const filter = (className) => {
+		if (output.removeUniversalSelector && className === "*") return false;
+		if (typeof options.filter === "function") return options.filter(className) !== false;
+		return true;
+	};
+	return {
+		projectRoot,
+		overwrite,
+		tailwind,
+		features: {
+			exposeContext,
+			extendLengthUnits
+		},
+		output,
+		cache,
+		filter
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/tsdown@0.21.10_synckit@0.11.12_typescript@6.0.3/node_modules/tsdown/esm-shims.js
+const getFilename = () => fileURLToPath(import.meta.url);
+const getDirname = () => path$1.dirname(getFilename());
+const __dirname = /* @__PURE__ */ getDirname();
+//#endregion
+//#region src/config/workspace.ts
+let configModulePromise;
+let defuPromise;
+function isNodeError$1(error) {
+	return !!error && typeof error === "object" && ("code" in error || "message" in error);
+}
+function isMissingModuleError(error, pkgName) {
+	if (!isNodeError$1(error)) return false;
+	const code = error.code;
+	if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") return false;
+	const message = error.message ?? "";
+	return message.includes(pkgName) || message.includes(`${pkgName}/dist/`);
+}
+function isMissingConfigModuleError(error) {
+	return isMissingModuleError(error, "@tailwindcss-mangle/config");
+}
+function isMissingSharedModuleError(error) {
+	return isMissingModuleError(error, "@tailwindcss-mangle/shared");
+}
+async function loadWorkspaceConfigModule() {
+	if (!configModulePromise) configModulePromise = import("@tailwindcss-mangle/config").catch(async (error) => {
+		if (!isMissingConfigModuleError(error)) throw error;
+		return import(pathToFileURL(path.resolve(__dirname, "../../../config/src/index.ts")).href);
+	});
+	return configModulePromise;
+}
+async function loadWorkspaceDefu() {
+	if (!defuPromise) defuPromise = import("./dist-BjUV1yEM.mjs").then((mod) => mod.defu).catch(async (error) => {
+		if (!isMissingSharedModuleError(error)) throw error;
+		return (await import(pathToFileURL(path.resolve(__dirname, "../../../shared/src/utils.ts")).href)).defu;
+	});
+	return defuPromise;
+}
+async function loadPatchOptionsForWorkspace(cwd, overrides) {
+	const merge = await loadWorkspaceDefu();
+	const { config } = await (await loadWorkspaceConfigModule()).getConfig(cwd);
+	if (config && typeof config === "object" && "patch" in config && config.patch !== void 0) throw new Error("Legacy workspace config field \"patch\" is no longer supported. Move patcher options under \"registry\".");
+	const base = config?.registry ? fromUnifiedConfig(config.registry) : {};
+	return merge(overrides ?? {}, base, { projectRoot: cwd });
+}
+//#endregion
+//#region src/v4/candidates.ts
+function resolveValidTailwindV4Candidates(designSystem, candidates) {
+	const validCandidates = /* @__PURE__ */ new Set();
+	const parsedCandidates = [];
+	for (const candidate of candidates) {
+		if (!candidate || parsedCandidates.includes(candidate)) continue;
+		if (designSystem.parseCandidate(candidate).length > 0) parsedCandidates.push(candidate);
+	}
+	if (parsedCandidates.length === 0) return validCandidates;
+	const cssByCandidate = designSystem.candidatesToCss(parsedCandidates);
+	for (let index = 0; index < parsedCandidates.length; index++) {
+		const candidate = parsedCandidates[index];
+		const candidateCss = cssByCandidate[index];
+		if (candidate && typeof candidateCss === "string" && candidateCss.trim().length > 0) validCandidates.add(candidate);
+	}
+	return validCandidates;
+}
+function splitTopLevel(value, separator) {
+	const result = [];
+	let start = 0;
+	let depth = 0;
+	let quote;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (character === "\\") {
+			index++;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = void 0;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(" || character === "[" || character === "{") {
+			depth++;
+			continue;
+		}
+		if (character === ")" || character === "]" || character === "}") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (depth === 0 && character === separator) {
+			const item = value.slice(start, index).trim();
+			if (item) result.push(item);
+			start = index + 1;
+		}
+	}
+	const item = value.slice(start).trim();
+	if (item) result.push(item);
+	return result;
+}
+const sequencePattern = /^(-?\d+)\.\.(-?\d+)(?:\.\.(-?\d+))?$/;
+function expandSequence(value) {
+	const match = value.match(sequencePattern);
+	if (!match) return [value];
+	const [, startValue, endValue, stepValue] = match;
+	if (startValue === void 0 || endValue === void 0) return [value];
+	const start = Number.parseInt(startValue, 10);
+	const end = Number.parseInt(endValue, 10);
+	let step = stepValue === void 0 ? start <= end ? 1 : -1 : Number.parseInt(stepValue, 10);
+	if (step === 0) throw new Error("Step cannot be zero in Tailwind CSS v4 inline source sequence.");
+	const ascending = start < end;
+	if (ascending && step < 0) step = -step;
+	if (!ascending && step > 0) step = -step;
+	const result = [];
+	for (let current = start; ascending ? current <= end : current >= end; current += step) result.push(current.toString());
+	return result;
+}
+function expandInlinePattern(pattern) {
+	const openIndex = pattern.indexOf("{");
+	if (openIndex === -1) return [pattern];
+	const prefix = pattern.slice(0, openIndex);
+	const rest = pattern.slice(openIndex);
+	let depth = 0;
+	let closeIndex = -1;
+	for (let index = 0; index < rest.length; index++) {
+		const character = rest[index];
+		if (character === "{") depth++;
+		else if (character === "}") {
+			depth--;
+			if (depth === 0) {
+				closeIndex = index;
+				break;
+			}
+		}
+	}
+	if (closeIndex === -1) throw new Error(`The Tailwind CSS v4 inline source pattern "${pattern}" is not balanced.`);
+	const body = rest.slice(1, closeIndex);
+	const suffix = rest.slice(closeIndex + 1);
+	const parts = sequencePattern.test(body) ? expandSequence(body) : splitTopLevel(body, ",").flatMap((part) => expandInlinePattern(part));
+	const suffixes = expandInlinePattern(suffix);
+	const result = [];
+	for (const part of parts) for (const expandedSuffix of suffixes) result.push(`${prefix}${part}${expandedSuffix}`);
+	return result;
+}
+function unquoteCssString(value) {
+	const quote = value[0];
+	if (quote !== "\"" && quote !== "'" || value[value.length - 1] !== quote) return;
+	let result = "";
+	for (let index = 1; index < value.length - 1; index++) {
+		const character = value[index];
+		if (character === "\\") {
+			index++;
+			result += value[index] ?? "";
+			continue;
+		}
+		result += character;
+	}
+	return result;
+}
+function extractTailwindV4InlineSourceCandidates(css) {
+	const included = /* @__PURE__ */ new Set();
+	const excluded = /* @__PURE__ */ new Set();
+	postcss.parse(css).walkAtRules("source", (rule) => {
+		let params = rule.params.trim();
+		if (!params) return;
+		let negated = false;
+		if (params.startsWith("not ")) {
+			negated = true;
+			params = params.slice(4).trim();
+		}
+		if (!params.startsWith("inline(") || !params.endsWith(")")) return;
+		const inlineValue = unquoteCssString(params.slice(7, -1).trim());
+		if (inlineValue === void 0) return;
+		const target = negated ? excluded : included;
+		for (const part of splitTopLevel(inlineValue, " ")) for (const candidate of expandInlinePattern(part)) target.add(candidate);
+	});
+	return {
+		included,
+		excluded
+	};
+}
+//#endregion
+//#region src/v4/node-adapter.ts
+const nodeModulePromiseCache = /* @__PURE__ */ new Map();
+const designSystemPromiseCache = /* @__PURE__ */ new Map();
+function unique(values) {
+	return Array.from(new Set(Array.from(values).filter(Boolean).map((value) => path.resolve(value))));
+}
+function createRequireBase(base) {
+	return path.join(base, "package.json");
+}
+async function importResolvedModule(resolved) {
+	return import(pathToFileURL(resolved).href);
+}
+async function importTailwindNodeFromBase(base) {
+	try {
+		return await importResolvedModule(createRequire(createRequireBase(base)).resolve("@tailwindcss/node"));
+	} catch {
+		return;
+	}
+}
+async function importFallbackTailwindNode() {
+	return import("@tailwindcss/node");
+}
+async function loadTailwindV4NodeModule(baseCandidates) {
+	const bases = unique(baseCandidates);
+	const cacheKey = JSON.stringify(bases);
+	const cached = nodeModulePromiseCache.get(cacheKey);
+	if (cached) return cached;
+	const promise = (async () => {
+		for (const base of bases) {
+			const loaded = await importTailwindNodeFromBase(base);
+			if (loaded) return loaded;
+		}
+		return importFallbackTailwindNode();
+	})();
+	nodeModulePromiseCache.set(cacheKey, promise);
+	promise.catch(() => {
+		if (nodeModulePromiseCache.get(cacheKey) === promise) nodeModulePromiseCache.delete(cacheKey);
+	});
+	return promise;
+}
+function createDesignSystemCacheKey(css, bases) {
+	return JSON.stringify({
+		css,
+		bases: unique(bases)
+	});
+}
+function getTailwindV4DesignSystemCacheKey(source) {
+	return createDesignSystemCacheKey(source.css, [source.base, ...source.baseFallbacks]);
+}
+async function loadTailwindV4DesignSystem(source) {
+	const bases = unique([source.base, ...source.baseFallbacks]);
+	if (bases.length === 0) throw new Error("No base directories provided for Tailwind CSS v4 design system.");
+	const cacheKey = createDesignSystemCacheKey(source.css, bases);
+	const cached = designSystemPromiseCache.get(cacheKey);
+	if (cached) return cached;
+	const promise = (async () => {
+		const node = await loadTailwindV4NodeModule([source.projectRoot, ...bases]);
+		let lastError;
+		for (const base of bases) try {
+			return await node.__unstable__loadDesignSystem(source.css, { base });
+		} catch (error) {
+			lastError = error;
+		}
+		if (lastError instanceof Error) throw lastError;
+		throw new Error("Failed to load Tailwind CSS v4 design system.");
+	})();
+	designSystemPromiseCache.set(cacheKey, promise);
+	promise.catch(() => {
+		if (designSystemPromiseCache.get(cacheKey) === promise) designSystemPromiseCache.delete(cacheKey);
+	});
+	return promise;
+}
+async function compileTailwindV4Source(source) {
+	const node = await loadTailwindV4NodeModule([
+		source.projectRoot,
+		source.base,
+		...source.baseFallbacks
+	]);
+	const dependencies = new Set(source.dependencies);
+	return {
+		compiled: await node.compile(source.css, {
+			base: source.base,
+			onDependency(dependency) {
+				dependencies.add(path.resolve(dependency));
+			}
+		}),
+		dependencies
+	};
+}
+//#endregion
+//#region src/extraction/candidate-extractor.ts
+let oxideImportPromise;
+const designSystemCandidateCache = /* @__PURE__ */ new Map();
+async function importOxide() {
+	return import("@tailwindcss/oxide");
+}
+function getOxideModule() {
+	oxideImportPromise ??= importOxide();
+	return oxideImportPromise;
+}
+async function extractRawCandidatesWithPositions(content, extension = "html") {
+	const { Scanner } = await getOxideModule();
+	return new Scanner({}).getCandidatesWithPositions({
+		content,
+		extension
+	}).map(({ candidate, position }) => ({
+		rawCandidate: candidate,
+		start: position,
+		end: position + candidate.length
+	}));
+}
+async function extractRawCandidates(sources) {
+	const { Scanner } = await getOxideModule();
+	return new Scanner(sources === void 0 ? {} : { sources }).scan();
+}
+async function extractValidCandidates(options) {
+	const providedOptions = options ?? {};
+	const defaultCwd = providedOptions.cwd ?? process.cwd();
+	const base = providedOptions.base ?? defaultCwd;
+	const baseFallbacks = providedOptions.baseFallbacks ?? [];
+	const css = providedOptions.css ?? "@import \"tailwindcss\";";
+	const sources = (providedOptions.sources ?? [{
+		base: defaultCwd,
+		pattern: "**/*",
+		negated: false
+	}]).map((source) => ({
+		base: source.base ?? defaultCwd,
+		pattern: source.pattern,
+		negated: source.negated
+	}));
+	const source = {
+		projectRoot: defaultCwd,
+		base,
+		baseFallbacks,
+		css,
+		dependencies: []
+	};
+	const designSystemKey = getTailwindV4DesignSystemCacheKey(source);
+	const designSystem = await loadTailwindV4DesignSystem(source);
+	const candidateCache = designSystemCandidateCache.get(designSystemKey) ?? /* @__PURE__ */ new Map();
+	designSystemCandidateCache.set(designSystemKey, candidateCache);
+	const candidates = await extractRawCandidates(sources);
+	const validCandidates = [];
+	const uncachedCandidates = [];
+	for (const rawCandidate of candidates) {
+		const cached = candidateCache.get(rawCandidate);
+		if (cached === true) {
+			validCandidates.push(rawCandidate);
+			continue;
+		}
+		if (cached === false) continue;
+		if (designSystem.parseCandidate(rawCandidate).length > 0) {
+			uncachedCandidates.push(rawCandidate);
+			continue;
+		}
+		candidateCache.set(rawCandidate, false);
+	}
+	if (uncachedCandidates.length === 0) return validCandidates;
+	const validUncachedCandidates = resolveValidTailwindV4Candidates(designSystem, uncachedCandidates);
+	for (const candidate of uncachedCandidates) {
+		const isValid = validUncachedCandidates.has(candidate);
+		candidateCache.set(candidate, isValid);
+		if (!isValid) continue;
+		validCandidates.push(candidate);
+	}
+	return validCandidates;
+}
+function normalizeSources(sources, cwd) {
+	return (sources?.length ? sources : [{
+		base: cwd,
+		pattern: "**/*",
+		negated: false
+	}]).map((source) => ({
+		base: source.base ?? cwd,
+		pattern: source.pattern,
+		negated: source.negated
+	}));
+}
+function buildLineOffsets(content) {
+	const offsets = [0];
+	for (let i = 0; i < content.length; i++) if (content[i] === "\n") offsets.push(i + 1);
+	if (offsets[offsets.length - 1] !== content.length) offsets.push(content.length);
+	return offsets;
+}
+function resolveLineMeta(content, offsets, index) {
+	let low = 0;
+	let high = offsets.length - 1;
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const start = offsets[mid];
+		if (start === void 0) break;
+		const nextStart = offsets[mid + 1] ?? content.length;
+		if (index < start) {
+			high = mid - 1;
+			continue;
+		}
+		if (index >= nextStart) {
+			low = mid + 1;
+			continue;
+		}
+		const line = mid + 1;
+		const column = index - start + 1;
+		const lineEnd = content.indexOf("\n", start);
+		return {
+			line,
+			column,
+			lineText: content.slice(start, lineEnd === -1 ? content.length : lineEnd)
+		};
+	}
+	const lastStart = offsets[offsets.length - 2] ?? 0;
+	return {
+		line: offsets.length - 1,
+		column: index - lastStart + 1,
+		lineText: content.slice(lastStart)
+	};
+}
+function toExtension(filename) {
+	return path.extname(filename).replace(/^\./, "") || "txt";
+}
+function toRelativeFile(cwd, filename) {
+	const relative = path.relative(cwd, filename);
+	return relative === "" ? path.basename(filename) : relative;
+}
+async function extractProjectCandidatesWithPositions(options) {
+	const cwd = options?.cwd ? path.resolve(options.cwd) : process.cwd();
+	const normalizedSources = normalizeSources(options?.sources, cwd);
+	const { Scanner } = await getOxideModule();
+	const scanner = new Scanner({ sources: normalizedSources });
+	const files = scanner.files ?? [];
+	const entries = [];
+	const skipped = [];
+	for (const file of files) {
+		let content;
+		try {
+			content = await promises.readFile(file, "utf8");
+		} catch (error) {
+			skipped.push({
+				file,
+				reason: error instanceof Error ? error.message : "Unknown error"
+			});
+			continue;
+		}
+		const extension = toExtension(file);
+		const matches = scanner.getCandidatesWithPositions({
+			file,
+			content,
+			extension
+		});
+		if (!matches.length) continue;
+		const offsets = buildLineOffsets(content);
+		const relativeFile = toRelativeFile(cwd, file);
+		for (const match of matches) {
+			const info = resolveLineMeta(content, offsets, match.position);
+			entries.push({
+				rawCandidate: match.candidate,
+				file,
+				relativeFile,
+				extension,
+				start: match.position,
+				end: match.position + match.candidate.length,
+				length: match.candidate.length,
+				line: info.line,
+				column: info.column,
+				lineText: info.lineText
+			});
+		}
+	}
+	return {
+		entries,
+		filesScanned: files.length,
+		skippedFiles: skipped,
+		sources: normalizedSources
+	};
+}
+function groupTokensByFile(report, options) {
+	const key = options?.key ?? "relative";
+	const stripAbsolute = options?.stripAbsolutePaths ?? key !== "absolute";
+	return report.entries.reduce((acc, entry) => {
+		const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
+		const bucket = acc[bucketKey] ?? (acc[bucketKey] = []);
+		const value = stripAbsolute ? {
+			...entry,
+			file: entry.relativeFile
+		} : entry;
+		bucket.push(value);
+		return acc;
+	}, {});
+}
+//#endregion
+//#region src/utils.ts
+function isObject(val) {
+	return val !== null && typeof val === "object" && Array.isArray(val) === false;
+}
+/**
+* Apply the changes to the string such that a change in the length
+* of the string does not break the indexes of the subsequent changes.
+*/
+function spliceChangesIntoString(str, changes) {
+	const firstChange = changes[0];
+	if (!firstChange) return str;
+	changes.sort((a, b) => {
+		return a.end - b.end || a.start - b.start;
+	});
+	let result = "";
+	let previous = firstChange;
+	result += str.slice(0, previous.start);
+	result += previous.replacement;
+	for (let i = 1; i < changes.length; ++i) {
+		const change = changes[i];
+		if (!change) continue;
+		result += str.slice(previous.end, change.start);
+		result += change.replacement;
+		previous = change;
+	}
+	result += str.slice(previous.end);
+	return result;
+}
+//#endregion
+//#region src/runtime/class-collector.ts
+function collectRuntimeCandidateKeys(context) {
+	const candidateRuleCache = context.candidateRuleCache;
+	if (candidateRuleCache instanceof Map && candidateRuleCache.size > 0) return candidateRuleCache.keys();
+	return context.classCache.keys();
+}
+function collectClassesFromContexts(contexts, filter) {
+	const set = /* @__PURE__ */ new Set();
+	for (const context of contexts) {
+		if (!isObject(context) || !context.classCache) continue;
+		for (const key of collectRuntimeCandidateKeys(context)) {
+			const className = key.toString();
+			if (filter(className)) set.add(className);
+		}
+	}
+	return set;
+}
+async function collectClassesFromTailwindV4(options) {
+	const set = /* @__PURE__ */ new Set();
+	const v4Options = options.tailwind.v4;
+	if (!v4Options) return set;
+	const toAbsolute = (value) => {
+		if (!value) return;
+		return path.isAbsolute(value) ? value : path.resolve(options.projectRoot, value);
+	};
+	const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
+	const resolvedDefaultBase = toAbsolute(v4Options.base) ?? process.cwd();
+	const resolveSources = (base) => {
+		if (!v4Options.sources?.length) return;
+		return v4Options.sources.map((source) => ({
+			base: source.base ?? base,
+			pattern: source.pattern,
+			negated: source.negated
+		}));
+	};
+	if (v4Options.cssEntries.length > 0) for (const entry of v4Options.cssEntries) {
+		const filePath = path.isAbsolute(entry) ? entry : path.resolve(options.projectRoot, entry);
+		if (!await fs.pathExists(filePath)) continue;
+		const css = await fs.readFile(filePath, "utf8");
+		const entryDir = path.dirname(filePath);
+		const designSystemBases = resolvedConfiguredBase && resolvedConfiguredBase !== entryDir ? [entryDir, resolvedConfiguredBase] : [entryDir];
+		const sources = resolveSources(resolvedConfiguredBase ?? entryDir);
+		const firstBase = designSystemBases[0] ?? entryDir;
+		const candidates = await extractValidCandidates({
+			cwd: options.projectRoot,
+			base: firstBase,
+			baseFallbacks: designSystemBases.slice(1),
+			css,
+			...sources === void 0 ? {} : { sources }
+		});
+		for (const candidate of candidates) if (options.filter(candidate)) set.add(candidate);
+	}
+	else {
+		const baseForCss = resolvedConfiguredBase ?? resolvedDefaultBase;
+		const sources = resolveSources(baseForCss);
+		const candidates = await extractValidCandidates({
+			cwd: options.projectRoot,
+			base: baseForCss,
+			...v4Options.css === void 0 ? {} : { css: v4Options.css },
+			...sources === void 0 ? {} : { sources }
+		});
+		for (const candidate of candidates) if (options.filter(candidate)) set.add(candidate);
+	}
+	return set;
+}
+//#endregion
+//#region src/runtime/context-registry.ts
+const require = createRequire(import.meta.url);
+function resolveRuntimeEntry(packageInfo, majorVersion) {
+	const root = packageInfo.rootPath;
+	if (majorVersion === 2) {
+		const jitIndex = path.join(root, "lib/jit/index.js");
+		if (fs.existsSync(jitIndex)) return jitIndex;
+	} else if (majorVersion === 3) {
+		const plugin = path.join(root, "lib/plugin.js");
+		const index = path.join(root, "lib/index.js");
+		if (fs.existsSync(plugin)) return plugin;
+		if (fs.existsSync(index)) return index;
+	}
+}
+function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
+	if (majorVersion === 4) return [];
+	const entry = resolveRuntimeEntry(packageInfo, majorVersion);
+	if (!entry) return [];
+	const moduleExports = require(entry);
+	if (!moduleExports) return [];
+	const ref = moduleExports[refProperty];
+	if (!ref) return [];
+	if (Array.isArray(ref)) return ref;
+	if (typeof ref === "object" && Array.isArray(ref.value)) return ref.value;
+	return [];
+}
+//#endregion
+//#region src/babel/index.ts
+function _interopDefaultCompat(e) {
+	return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+const generate$1 = _interopDefaultCompat(generate);
+const traverse = _interopDefaultCompat(_babelTraverse);
+//#endregion
+//#region src/patching/operations/export-context/postcss-v2.ts
+const IDENTIFIER_RE$1 = /^[A-Z_$][\w$]*$/i;
+function toIdentifierName$1(property) {
+	if (!property) return "contextRef";
+	const sanitized = property.replace(/[^\w$]/gu, "_");
+	if (/^\d/.test(sanitized)) return `_${sanitized}`;
+	return sanitized || "contextRef";
+}
+function createExportsMember(property) {
+	if (IDENTIFIER_RE$1.test(property)) return t.memberExpression(t.identifier("exports"), t.identifier(property));
+	return t.memberExpression(t.identifier("exports"), t.stringLiteral(property), true);
+}
+function transformProcessTailwindFeaturesReturnContextV2(content) {
+	const ast = parse$1(content, { sourceType: "unambiguous" });
+	let hasPatched = false;
+	traverse(ast, { FunctionDeclaration(path) {
+		const node = path.node;
+		if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) return;
+		const returnStatement = node.body.body[0];
+		if (!t.isFunctionExpression(returnStatement.argument)) return;
+		const body = returnStatement.argument.body.body;
+		const lastStatement = body[body.length - 1];
+		const alreadyReturnsContext = Boolean(t.isReturnStatement(lastStatement) && t.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context");
+		hasPatched = alreadyReturnsContext;
+		if (!alreadyReturnsContext) body.push(t.returnStatement(t.identifier("context")));
+	} });
+	return {
+		code: hasPatched ? content : generate$1(ast).code,
+		hasPatched
+	};
+}
+function transformPostcssPluginV2(content, options) {
+	const refIdentifier = t.identifier(toIdentifierName$1(options.refProperty));
+	const exportMember = createExportsMember(options.refProperty);
+	const valueMember = t.memberExpression(refIdentifier, t.identifier("value"));
+	const ast = parse$1(content);
+	let hasPatched = false;
+	traverse(ast, {
+		Program(path) {
+			const program = path.node;
+			const index = program.body.findIndex((statement) => {
+				return t.isFunctionDeclaration(statement) && statement.id?.name === "_default";
+			});
+			if (index === -1) return;
+			const previous = program.body[index - 1];
+			const beforePrevious = program.body[index - 2];
+			const alreadyHasVariable = Boolean(previous && t.isVariableDeclaration(previous) && previous.declarations.length === 1 && (() => {
+				const declaration = previous.declarations[0];
+				return Boolean(declaration && t.isIdentifier(declaration.id) && declaration.id.name === refIdentifier.name);
+			})());
+			const alreadyAssignsExports = Boolean(beforePrevious && t.isExpressionStatement(beforePrevious) && t.isAssignmentExpression(beforePrevious.expression) && t.isMemberExpression(beforePrevious.expression.left) && t.isIdentifier(beforePrevious.expression.right) && beforePrevious.expression.right.name === refIdentifier.name && generate$1(beforePrevious.expression.left).code === generate$1(exportMember).code);
+			hasPatched = alreadyHasVariable && alreadyAssignsExports;
+			if (!alreadyHasVariable) program.body.splice(index, 0, t.variableDeclaration("var", [t.variableDeclarator(refIdentifier, t.objectExpression([t.objectProperty(t.identifier("value"), t.arrayExpression())]))]), t.expressionStatement(t.assignmentExpression("=", exportMember, refIdentifier)));
+		},
+		FunctionDeclaration(path) {
+			if (hasPatched) return;
+			const fn = path.node;
+			if (fn.id?.name !== "_default") return;
+			if (fn.body.body.length !== 1 || !t.isReturnStatement(fn.body.body[0])) return;
+			const returnStatement = fn.body.body[0];
+			if (!t.isCallExpression(returnStatement.argument) || !t.isMemberExpression(returnStatement.argument.callee) || !t.isArrayExpression(returnStatement.argument.callee.object)) return;
+			const fnExpression = returnStatement.argument.callee.object.elements[1];
+			if (!fnExpression || !t.isFunctionExpression(fnExpression)) return;
+			const statements = fnExpression.body.body;
+			if (t.isExpressionStatement(statements[0]) && t.isAssignmentExpression(statements[0].expression) && t.isNumericLiteral(statements[0].expression.right)) {
+				hasPatched = true;
+				return;
+			}
+			const lastStatement = statements[statements.length - 1];
+			if (lastStatement && t.isExpressionStatement(lastStatement)) statements[statements.length - 1] = t.expressionStatement(t.callExpression(t.memberExpression(valueMember, t.identifier("push")), [lastStatement.expression]));
+			const index = statements.findIndex((statement) => t.isIfStatement(statement));
+			if (index > -1) {
+				const ifStatement = statements[index];
+				if (t.isBlockStatement(ifStatement.consequent) && ifStatement.consequent.body[1] && t.isForOfStatement(ifStatement.consequent.body[1])) {
+					const forOf = ifStatement.consequent.body[1];
+					if (t.isBlockStatement(forOf.body) && forOf.body.body.length === 1) {
+						const nestedIf = forOf.body.body[0];
+						if (nestedIf && t.isIfStatement(nestedIf) && t.isBlockStatement(nestedIf.consequent) && nestedIf.consequent.body.length === 1 && t.isExpressionStatement(nestedIf.consequent.body[0])) nestedIf.consequent.body[0] = t.expressionStatement(t.callExpression(t.memberExpression(valueMember, t.identifier("push")), [nestedIf.consequent.body[0].expression]));
+					}
+				}
+			}
+			statements.unshift(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(valueMember, t.identifier("length")), t.numericLiteral(0))));
+		}
+	});
+	return {
+		code: hasPatched ? content : generate$1(ast).code,
+		hasPatched
+	};
+}
+//#endregion
+//#region src/patching/operations/export-context/postcss-v3.ts
+const IDENTIFIER_RE = /^[A-Z_$][\w$]*$/i;
+function toIdentifierName(property) {
+	if (!property) return "contextRef";
+	const sanitized = property.replace(/[^\w$]/gu, "_");
+	if (/^\d/.test(sanitized)) return `_${sanitized}`;
+	return sanitized || "contextRef";
+}
+function createModuleExportsMember(property) {
+	const object = t.memberExpression(t.identifier("module"), t.identifier("exports"));
+	if (IDENTIFIER_RE.test(property)) return t.memberExpression(object, t.identifier(property));
+	return t.memberExpression(object, t.stringLiteral(property), true);
+}
+function transformProcessTailwindFeaturesReturnContext(content) {
+	const ast = parse$1(content);
+	let hasPatched = false;
+	traverse(ast, { FunctionDeclaration(path) {
+		const node = path.node;
+		if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1) return;
+		const [returnStatement] = node.body.body;
+		if (!t.isReturnStatement(returnStatement) || !t.isFunctionExpression(returnStatement.argument)) return;
+		const body = returnStatement.argument.body.body;
+		const lastStatement = body[body.length - 1];
+		const alreadyReturnsContext = Boolean(t.isReturnStatement(lastStatement) && t.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context");
+		hasPatched = alreadyReturnsContext;
+		if (!alreadyReturnsContext) body.push(t.returnStatement(t.identifier("context")));
+	} });
+	return {
+		code: hasPatched ? content : generate$1(ast).code,
+		hasPatched
+	};
+}
+function transformPostcssPlugin(content, { refProperty }) {
+	const ast = parse$1(content);
+	const refIdentifier = t.identifier(toIdentifierName(refProperty));
+	const moduleExportsMember = createModuleExportsMember(refProperty);
+	const valueMember = t.memberExpression(refIdentifier, t.identifier("value"));
+	let hasPatched = false;
+	traverse(ast, {
+		Program(path) {
+			const program = path.node;
+			const index = program.body.findIndex((statement) => {
+				return t.isExpressionStatement(statement) && t.isAssignmentExpression(statement.expression) && t.isMemberExpression(statement.expression.left) && t.isFunctionExpression(statement.expression.right) && statement.expression.right.id?.name === "tailwindcss";
+			});
+			if (index === -1) return;
+			const previousStatement = program.body[index - 1];
+			const lastStatement = program.body[program.body.length - 1];
+			const alreadyHasVariable = Boolean(previousStatement && t.isVariableDeclaration(previousStatement) && previousStatement.declarations.length === 1 && (() => {
+				const declaration = previousStatement.declarations[0];
+				return Boolean(declaration && t.isIdentifier(declaration.id) && declaration.id.name === refIdentifier.name);
+			})());
+			const alreadyAssignsModuleExports = Boolean(t.isExpressionStatement(lastStatement) && t.isAssignmentExpression(lastStatement.expression) && t.isMemberExpression(lastStatement.expression.left) && t.isIdentifier(lastStatement.expression.right) && lastStatement.expression.right.name === refIdentifier.name && generate$1(lastStatement.expression.left).code === generate$1(moduleExportsMember).code);
+			hasPatched = alreadyHasVariable && alreadyAssignsModuleExports;
+			if (!alreadyHasVariable) program.body.splice(index, 0, t.variableDeclaration("const", [t.variableDeclarator(refIdentifier, t.objectExpression([t.objectProperty(t.identifier("value"), t.arrayExpression())]))]));
+			if (!alreadyAssignsModuleExports) program.body.push(t.expressionStatement(t.assignmentExpression("=", moduleExportsMember, refIdentifier)));
+		},
+		FunctionExpression(path) {
+			if (hasPatched) return;
+			const fn = path.node;
+			if (fn.id?.name !== "tailwindcss" || fn.body.body.length !== 1) return;
+			const [returnStatement] = fn.body.body;
+			if (!returnStatement || !t.isReturnStatement(returnStatement) || !t.isObjectExpression(returnStatement.argument)) return;
+			const properties = returnStatement.argument.properties;
+			if (properties.length !== 2) return;
+			const pluginsProperty = properties.find((prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === "plugins");
+			if (!pluginsProperty || !t.isObjectProperty(pluginsProperty) || !t.isCallExpression(pluginsProperty.value) || !t.isMemberExpression(pluginsProperty.value.callee) || !t.isArrayExpression(pluginsProperty.value.callee.object)) return;
+			const targetPlugin = pluginsProperty.value.callee.object.elements[1];
+			if (!targetPlugin || !t.isFunctionExpression(targetPlugin)) return;
+			const statements = targetPlugin.body.body;
+			const last = statements[statements.length - 1];
+			if (last && t.isExpressionStatement(last)) statements[statements.length - 1] = t.expressionStatement(t.callExpression(t.memberExpression(valueMember, t.identifier("push")), [last.expression]));
+			const index = statements.findIndex((s) => t.isIfStatement(s));
+			if (index > -1) {
+				const ifStatement = statements[index];
+				if (t.isBlockStatement(ifStatement.consequent)) {
+					const [, second] = ifStatement.consequent.body;
+					if (second && t.isForOfStatement(second) && t.isBlockStatement(second.body)) {
+						const bodyStatement = second.body.body[0];
+						if (bodyStatement && t.isIfStatement(bodyStatement) && t.isBlockStatement(bodyStatement.consequent) && bodyStatement.consequent.body.length === 1 && t.isExpressionStatement(bodyStatement.consequent.body[0])) bodyStatement.consequent.body[0] = t.expressionStatement(t.callExpression(t.memberExpression(valueMember, t.identifier("push")), [bodyStatement.consequent.body[0].expression]));
+					}
+				}
+			}
+			statements.unshift(t.expressionStatement(t.assignmentExpression("=", t.memberExpression(valueMember, t.identifier("length")), t.numericLiteral(0))));
+		}
+	});
+	return {
+		code: hasPatched ? content : generate$1(ast).code,
+		hasPatched
+	};
+}
+//#endregion
+//#region src/patching/operations/export-context/index.ts
+function writeFileIfRequired(filePath, code, overwrite, successMessage) {
+	if (!overwrite) return;
+	fs.writeFileSync(filePath, code, { encoding: "utf8" });
+	logger.success(successMessage);
+}
+function applyExposeContextPatch(params) {
+	const { rootDir, refProperty, overwrite, majorVersion } = params;
+	const result = {
+		applied: false,
+		files: {}
+	};
+	if (majorVersion === 3) {
+		const processFileRelative = "lib/processTailwindFeatures.js";
+		const processFilePath = path.resolve(rootDir, processFileRelative);
+		if (fs.existsSync(processFilePath)) {
+			const { code, hasPatched } = transformProcessTailwindFeaturesReturnContext(fs.readFileSync(processFilePath, "utf8"));
+			result.files[processFileRelative] = code;
+			if (!hasPatched) {
+				writeFileIfRequired(processFilePath, code, overwrite, "Patched Tailwind CSS processTailwindFeatures to expose runtime context.");
+				result.applied = true;
+			}
+		}
+		const pluginRelative = ["lib/plugin.js", "lib/index.js"].find((candidate) => fs.existsSync(path.resolve(rootDir, candidate)));
+		if (pluginRelative) {
+			const pluginPath = path.resolve(rootDir, pluginRelative);
+			const { code, hasPatched } = transformPostcssPlugin(fs.readFileSync(pluginPath, "utf8"), { refProperty });
+			result.files[pluginRelative] = code;
+			if (!hasPatched) {
+				writeFileIfRequired(pluginPath, code, overwrite, "Patched Tailwind CSS plugin entry to collect runtime contexts.");
+				result.applied = true;
+			}
+		}
+	} else if (majorVersion === 2) {
+		const processFileRelative = "lib/jit/processTailwindFeatures.js";
+		const processFilePath = path.resolve(rootDir, processFileRelative);
+		if (fs.existsSync(processFilePath)) {
+			const { code, hasPatched } = transformProcessTailwindFeaturesReturnContextV2(fs.readFileSync(processFilePath, "utf8"));
+			result.files[processFileRelative] = code;
+			if (!hasPatched) {
+				writeFileIfRequired(processFilePath, code, overwrite, "Patched Tailwind CSS JIT processTailwindFeatures to expose runtime context.");
+				result.applied = true;
+			}
+		}
+		const pluginRelative = "lib/jit/index.js";
+		const pluginPath = path.resolve(rootDir, pluginRelative);
+		if (fs.existsSync(pluginPath)) {
+			const { code, hasPatched } = transformPostcssPluginV2(fs.readFileSync(pluginPath, "utf8"), { refProperty });
+			result.files[pluginRelative] = code;
+			if (!hasPatched) {
+				writeFileIfRequired(pluginPath, code, overwrite, "Patched Tailwind CSS JIT entry to collect runtime contexts.");
+				result.applied = true;
+			}
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/patching/operations/extend-length-units.ts
+function updateLengthUnitsArray(content, options) {
+	const { variableName = "lengthUnits", units } = options;
+	const ast = parse$1(content);
+	let arrayRef;
+	let changed = false;
+	traverse(ast, { Identifier(path) {
+		if (path.node.name === variableName && t.isVariableDeclarator(path.parent) && t.isArrayExpression(path.parent.init)) {
+			arrayRef = path.parent.init;
+			const existing = new Set(path.parent.init.elements.map((element) => t.isStringLiteral(element) ? element.value : void 0).filter(Boolean));
+			for (const unit of units) if (!existing.has(unit)) {
+				path.parent.init.elements = path.parent.init.elements.map((element) => {
+					if (t.isStringLiteral(element)) return t.stringLiteral(element.value);
+					return element;
+				});
+				path.parent.init.elements.push(t.stringLiteral(unit));
+				changed = true;
+			}
+		}
+	} });
+	return {
+		...arrayRef === void 0 ? {} : { arrayRef },
+		changed
+	};
+}
+function applyExtendLengthUnitsPatchV3(rootDir, options) {
+	if (!options.enabled) return {
+		changed: false,
+		code: void 0
+	};
+	const opts = {
+		...options,
+		lengthUnitsFilePath: options.lengthUnitsFilePath ?? "lib/util/dataTypes.js",
+		variableName: options.variableName ?? "lengthUnits"
+	};
+	const dataTypesFilePath = path.resolve(rootDir, opts.lengthUnitsFilePath);
+	if (!fs.existsSync(dataTypesFilePath)) return {
+		changed: false,
+		code: void 0
+	};
+	const content = fs.readFileSync(dataTypesFilePath, "utf8");
+	const { arrayRef, changed } = updateLengthUnitsArray(content, opts);
+	if (!arrayRef || !changed) return {
+		changed: false,
+		code: void 0
+	};
+	const { code } = generate$1(arrayRef, { jsescOption: { quotes: "single" } });
+	if (arrayRef.start != null && arrayRef.end != null) {
+		const nextCode = `${content.slice(0, arrayRef.start)}${code}${content.slice(arrayRef.end)}`;
+		if (opts.overwrite) {
+			const target = opts.destPath ? path.resolve(opts.destPath) : dataTypesFilePath;
+			fs.writeFileSync(target, nextCode, "utf8");
+			logger.success("Patched Tailwind CSS length unit list (v3).");
+		}
+		return {
+			changed: true,
+			code: nextCode
+		};
+	}
+	return {
+		changed: false,
+		code: void 0
+	};
+}
+function applyExtendLengthUnitsPatchV4(rootDir, options) {
+	if (!options.enabled) return {
+		files: [],
+		changed: false
+	};
+	const opts = { ...options };
+	const distDir = path.resolve(rootDir, "dist");
+	if (!fs.existsSync(distDir)) return {
+		files: [],
+		changed: false
+	};
+	const chunkNames = fs.readdirSync(distDir).filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs"));
+	const pattern = /\[\s*["']cm["'],\s*["']mm["'],[\w,"']+\]/;
+	const candidates = chunkNames.map((chunkName) => {
+		const file = path.join(distDir, chunkName);
+		const code = fs.readFileSync(file, "utf8");
+		const match = pattern.exec(code);
+		if (!match) return null;
+		return {
+			file,
+			code,
+			match,
+			hasPatched: false
+		};
+	}).filter((candidate) => candidate !== null);
+	for (const item of candidates) {
+		const { code, file, match } = item;
+		const ast = parse$1(match[0], { sourceType: "unambiguous" });
+		traverse(ast, { ArrayExpression(path) {
+			for (const unit of opts.units) {
+				if (path.node.elements.some((element) => t.isStringLiteral(element) && element.value === unit)) {
+					item.hasPatched = true;
+					return;
+				}
+				path.node.elements.push(t.stringLiteral(unit));
+			}
+		} });
+		if (item.hasPatched) continue;
+		const { code: replacement } = generate$1(ast, { minified: true });
+		const start = match.index ?? 0;
+		item.code = spliceChangesIntoString(code, [{
+			start,
+			end: start + match[0].length,
+			replacement: replacement.endsWith(";") ? replacement.slice(0, -1) : replacement
+		}]);
+		if (opts.overwrite) fs.writeFileSync(file, item.code, "utf8");
+	}
+	if (candidates.some((file) => !file.hasPatched)) logger.success("Patched Tailwind CSS length unit list (v4).");
+	return {
+		changed: candidates.some((file) => !file.hasPatched),
+		files: candidates
+	};
+}
+//#endregion
+//#region src/patching/patch-runner.ts
+function applyTailwindPatches(context) {
+	const { packageInfo, options, majorVersion } = context;
+	const results = {};
+	if (options.features.exposeContext.enabled && (majorVersion === 2 || majorVersion === 3)) results.exposeContext = applyExposeContextPatch({
+		rootDir: packageInfo.rootPath,
+		refProperty: options.features.exposeContext.refProperty,
+		overwrite: options.overwrite,
+		majorVersion
+	});
+	if (options.features.extendLengthUnits?.enabled) {
+		if (majorVersion === 3) results.extendLengthUnits = applyExtendLengthUnitsPatchV3(packageInfo.rootPath, options.features.extendLengthUnits);
+		else if (majorVersion === 4) results.extendLengthUnits = applyExtendLengthUnitsPatchV4(packageInfo.rootPath, options.features.extendLengthUnits);
+	}
+	return results;
+}
+//#endregion
+//#region src/runtime/process-tailwindcss.ts
+function createCwdRequire(cwd) {
+	return createRequire(path.join(cwd, "package.json"));
+}
+function resolveModuleEntry(id, moduleRequire) {
+	return path.isAbsolute(id) ? id : moduleRequire.resolve(id);
+}
+function resolvePackageRootFromEntry(entry) {
+	let current = path.dirname(entry);
+	while (current && current !== path.dirname(current)) {
+		const packageJsonPath = path.join(current, "package.json");
+		if (fs.pathExistsSync(packageJsonPath)) return current;
+		current = path.dirname(current);
+	}
+}
+function resolveCacheKey(moduleRequire, entry) {
+	try {
+		return moduleRequire.resolve(entry);
+	} catch {
+		return entry;
+	}
+}
+function clearTailwindV3RuntimeState(pluginName, moduleRequire) {
+	try {
+		const root = resolvePackageRootFromEntry(resolveModuleEntry(pluginName, moduleRequire));
+		if (!root) return;
+		const sharedStatePath = path.join(root, "lib/lib/sharedState.js");
+		if (!fs.pathExistsSync(sharedStatePath)) return;
+		const sharedStateKey = resolveCacheKey(moduleRequire, sharedStatePath);
+		const sharedState = moduleRequire.cache[sharedStateKey]?.exports;
+		sharedState?.contextMap?.clear();
+		sharedState?.configContextMap?.clear();
+		sharedState?.contextSourcesMap?.clear();
+		sharedState?.sourceHashMap?.clear();
+		for (const candidate of ["lib/plugin.js", "lib/index.js"]) {
+			const runtimeEntry = path.join(root, candidate);
+			if (!fs.pathExistsSync(runtimeEntry)) continue;
+			const runtimeKey = resolveCacheKey(moduleRequire, runtimeEntry);
+			const runtimeModule = moduleRequire.cache[runtimeKey]?.exports;
+			runtimeModule?.contextRef?.value?.splice(0, runtimeModule.contextRef.value.length);
+			break;
+		}
+	} catch {}
+}
+async function resolveConfigPath(options) {
+	if (options.config && path.isAbsolute(options.config)) return options.config;
+	const result = await loadConfig({ cwd: options.cwd });
+	if (!result) throw new Error(`Unable to locate Tailwind CSS config from ${options.cwd}`);
+	return result.filepath;
+}
+async function runTailwindBuild(options) {
+	const configPath = await resolveConfigPath(options);
+	const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss");
+	const moduleRequire = createCwdRequire(options.cwd);
+	if (options.majorVersion === 3) clearTailwindV3RuntimeState(pluginName, moduleRequire);
+	if (options.majorVersion === 4) return postcss([moduleRequire(pluginName)({ config: configPath })]).process("@import 'tailwindcss';", { from: void 0 });
+	return postcss([moduleRequire(pluginName)({ config: configPath })]).process("@tailwind base;@tailwind components;@tailwind utilities;", { from: void 0 });
+}
+//#endregion
+//#region src/patching/status.ts
+function inspectLengthUnitsArray(content, variableName, units) {
+	const ast = parse$1(content);
+	let found = false;
+	let missingUnits = [];
+	traverse(ast, { Identifier(path) {
+		if (path.node.name === variableName && t.isVariableDeclarator(path.parent) && t.isArrayExpression(path.parent.init)) {
+			found = true;
+			const existing = new Set(path.parent.init.elements.map((element) => t.isStringLiteral(element) ? element.value : void 0).filter(Boolean));
+			missingUnits = units.filter((unit) => !existing.has(unit));
+			path.stop();
+		}
+	} });
+	return {
+		found,
+		missingUnits
+	};
+}
+function checkExposeContextPatch(context) {
+	const { packageInfo, options, majorVersion } = context;
+	const refProperty = options.features.exposeContext.refProperty;
+	if (!options.features.exposeContext.enabled) return {
+		name: "exposeContext",
+		status: "skipped",
+		reason: "exposeContext feature disabled",
+		files: []
+	};
+	if (majorVersion === 4) return {
+		name: "exposeContext",
+		status: "unsupported",
+		reason: "Context export patch is only required for Tailwind v2/v3",
+		files: []
+	};
+	const checks = [];
+	function inspectFile(relative, transform) {
+		const filePath = path.resolve(packageInfo.rootPath, relative);
+		if (!fs.existsSync(filePath)) {
+			checks.push({
+				relative,
+				exists: false,
+				patched: false
+			});
+			return;
+		}
+		const { hasPatched } = transform(fs.readFileSync(filePath, "utf8"));
+		checks.push({
+			relative,
+			exists: true,
+			patched: hasPatched
+		});
+	}
+	if (majorVersion === 3) {
+		inspectFile("lib/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContext);
+		const pluginRelative = ["lib/plugin.js", "lib/index.js"].find((candidate) => fs.existsSync(path.resolve(packageInfo.rootPath, candidate)));
+		if (pluginRelative) inspectFile(pluginRelative, (content) => transformPostcssPlugin(content, { refProperty }));
+		else checks.push({
+			relative: "lib/plugin.js",
+			exists: false,
+			patched: false
+		});
+	} else {
+		inspectFile("lib/jit/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContextV2);
+		inspectFile("lib/jit/index.js", (content) => transformPostcssPluginV2(content, { refProperty }));
+	}
+	const files = checks.filter((check) => check.exists).map((check) => check.relative);
+	const missingFiles = checks.filter((check) => !check.exists);
+	const unpatchedFiles = checks.filter((check) => check.exists && !check.patched);
+	const reasons = [];
+	if (missingFiles.length) reasons.push(`missing files: ${missingFiles.map((item) => item.relative).join(", ")}`);
+	if (unpatchedFiles.length) reasons.push(`unpatched files: ${unpatchedFiles.map((item) => item.relative).join(", ")}`);
+	return {
+		name: "exposeContext",
+		status: reasons.length ? "not-applied" : "applied",
+		...reasons.length ? { reason: reasons.join("; ") } : {},
+		files
+	};
+}
+function checkExtendLengthUnitsV3(rootDir, options) {
+	const lengthUnitsFilePath = options.lengthUnitsFilePath ?? "lib/util/dataTypes.js";
+	const variableName = options.variableName ?? "lengthUnits";
+	const target = path.resolve(rootDir, lengthUnitsFilePath);
+	const files = fs.existsSync(target) ? [path.relative(rootDir, target)] : [];
+	if (!fs.existsSync(target)) return {
+		name: "extendLengthUnits",
+		status: "not-applied",
+		reason: `missing ${lengthUnitsFilePath}`,
+		files
+	};
+	const { found, missingUnits } = inspectLengthUnitsArray(fs.readFileSync(target, "utf8"), variableName, options.units);
+	if (!found) return {
+		name: "extendLengthUnits",
+		status: "not-applied",
+		reason: `could not locate ${variableName} array in ${lengthUnitsFilePath}`,
+		files
+	};
+	if (missingUnits.length) return {
+		name: "extendLengthUnits",
+		status: "not-applied",
+		reason: `missing units: ${missingUnits.join(", ")}`,
+		files
+	};
+	return {
+		name: "extendLengthUnits",
+		status: "applied",
+		files
+	};
+}
+function checkExtendLengthUnitsV4(rootDir, options) {
+	const distDir = path.resolve(rootDir, "dist");
+	if (!fs.existsSync(distDir)) return {
+		name: "extendLengthUnits",
+		status: "not-applied",
+		reason: "dist directory not found for Tailwind v4 package",
+		files: []
+	};
+	const result = applyExtendLengthUnitsPatchV4(rootDir, {
+		...options,
+		enabled: true,
+		overwrite: false
+	});
+	if (result.files.length === 0) return {
+		name: "extendLengthUnits",
+		status: "not-applied",
+		reason: "no bundle chunks matched the length unit pattern",
+		files: []
+	};
+	const files = result.files.map((file) => path.relative(rootDir, file.file));
+	const pending = result.files.filter((file) => !file.hasPatched);
+	if (pending.length) return {
+		name: "extendLengthUnits",
+		status: "not-applied",
+		reason: `missing units in ${pending.length} bundle${pending.length > 1 ? "s" : ""}`,
+		files: pending.map((file) => path.relative(rootDir, file.file))
+	};
+	return {
+		name: "extendLengthUnits",
+		status: "applied",
+		files
+	};
+}
+function checkExtendLengthUnitsPatch(context) {
+	const { packageInfo, options, majorVersion } = context;
+	if (!options.features.extendLengthUnits) return {
+		name: "extendLengthUnits",
+		status: "skipped",
+		reason: "extendLengthUnits feature disabled",
+		files: []
+	};
+	if (majorVersion === 2) return {
+		name: "extendLengthUnits",
+		status: "unsupported",
+		reason: "length unit extension is only applied for Tailwind v3/v4",
+		files: []
+	};
+	if (majorVersion === 3) return checkExtendLengthUnitsV3(packageInfo.rootPath, options.features.extendLengthUnits);
+	return checkExtendLengthUnitsV4(packageInfo.rootPath, options.features.extendLengthUnits);
+}
+function getPatchStatusReport(context) {
+	return {
+		package: {
+			name: context.packageInfo.name ?? context.packageInfo.packageJson?.name,
+			version: context.packageInfo.version,
+			root: context.packageInfo.rootPath
+		},
+		majorVersion: context.majorVersion,
+		entries: [checkExposeContextPatch(context), checkExtendLengthUnitsPatch(context)]
+	};
+}
+//#endregion
+//#region src/runtime/collector.ts
+function resolveTailwindExecutionOptions(normalized, majorVersion) {
+	const base = normalized.tailwind;
+	if (majorVersion === 2 && base.v2) return {
+		cwd: base.v2.cwd ?? base.cwd ?? normalized.projectRoot,
+		config: base.v2.config ?? base.config,
+		postcssPlugin: base.v2.postcssPlugin ?? base.postcssPlugin
+	};
+	if (majorVersion === 3 && base.v3) return {
+		cwd: base.v3.cwd ?? base.cwd ?? normalized.projectRoot,
+		config: base.v3.config ?? base.config,
+		postcssPlugin: base.v3.postcssPlugin ?? base.postcssPlugin
+	};
+	return {
+		cwd: base.cwd ?? normalized.projectRoot,
+		config: base.config,
+		postcssPlugin: base.postcssPlugin
+	};
+}
+var BaseCollector = class {
+	constructor(packageInfo, options, majorVersion) {
+		this.packageInfo = packageInfo;
+		this.options = options;
+		this.majorVersion = majorVersion;
+	}
+	async patch() {
+		return applyTailwindPatches({
+			packageInfo: this.packageInfo,
+			options: this.options,
+			majorVersion: this.majorVersion
+		});
+	}
+	async getPatchStatus() {
+		return getPatchStatusReport({
+			packageInfo: this.packageInfo,
+			options: this.options,
+			majorVersion: this.majorVersion
+		});
+	}
+	getContexts() {
+		return loadRuntimeContexts(this.packageInfo, this.majorVersion, this.options.features.exposeContext.refProperty);
+	}
+};
+var RuntimeCollector = class extends BaseCollector {
+	inFlightBuild;
+	constructor(packageInfo, options, majorVersion, snapshotFactory) {
+		super(packageInfo, options, majorVersion);
+		this.snapshotFactory = snapshotFactory;
+	}
+	async collectClassSet() {
+		return collectClassesFromContexts(this.getContexts(), this.options.filter);
+	}
+	getPatchSnapshot() {
+		return this.snapshotFactory();
+	}
+	async runTailwindBuildIfNeeded() {
+		if (this.inFlightBuild) return this.inFlightBuild;
+		const executionOptions = resolveTailwindExecutionOptions(this.options, this.majorVersion);
+		const buildOptions = {
+			cwd: executionOptions.cwd,
+			majorVersion: this.majorVersion,
+			...executionOptions.config === void 0 ? {} : { config: executionOptions.config },
+			...executionOptions.postcssPlugin === void 0 ? {} : { postcssPlugin: executionOptions.postcssPlugin }
+		};
+		this.inFlightBuild = runTailwindBuild(buildOptions).then(() => void 0);
+		try {
+			await this.inFlightBuild;
+		} finally {
+			this.inFlightBuild = void 0;
+		}
+	}
+};
+var TailwindV4Collector = class extends BaseCollector {
+	constructor(packageInfo, options, snapshotFactory) {
+		super(packageInfo, options, 4);
+		this.snapshotFactory = snapshotFactory;
+	}
+	snapshotFactory;
+	async collectClassSet() {
+		return collectClassesFromTailwindV4(this.options);
+	}
+	getPatchSnapshot() {
+		return this.snapshotFactory();
+	}
+};
+//#endregion
+//#region src/api/tailwindcss-patcher.ts
+function resolveInstalledMajorVersion(version) {
+	if (!version) return;
+	const coerced = coerce(version);
+	if (!coerced) return;
+	const major = coerced.major;
+	if (major === 2 || major === 3 || major === 4) return major;
+	if (major >= 4) return 4;
+}
+function validateInstalledVersion(packageVersion, expectedMajor, packageName) {
+	const installedMajor = resolveInstalledMajorVersion(packageVersion);
+	if (installedMajor === void 0) return;
+	if (installedMajor !== expectedMajor) throw new Error(`Configured tailwindcss.version=${expectedMajor}, but resolved package "${packageName}" is version ${packageVersion}. Update the configuration or resolve the correct package.`);
+}
+function resolveMajorVersionOrThrow(configuredMajor, packageVersion, packageName) {
+	if (configuredMajor !== void 0) {
+		validateInstalledVersion(packageVersion, configuredMajor, packageName);
+		return configuredMajor;
+	}
+	const installedMajor = resolveInstalledMajorVersion(packageVersion);
+	if (installedMajor !== void 0) return installedMajor;
+	throw new Error(`Unable to infer Tailwind CSS major version from resolved package "${packageName}" (${packageVersion ?? "unknown"}). Set "tailwindcss.version" to 2, 3, or 4 explicitly.`);
+}
+function createCollector(packageInfo, options, majorVersion, snapshotFactory) {
+	if (majorVersion === 4) return new TailwindV4Collector(packageInfo, options, snapshotFactory);
+	return new RuntimeCollector(packageInfo, options, majorVersion, snapshotFactory);
+}
+function getPackageInfoFromCwd(packageName, cwd) {
+	try {
+		const packageJsonPath = createRequire(path.join(cwd, "package.json")).resolve(`${packageName}/package.json`);
+		const packageJson = fs.readJSONSync(packageJsonPath);
+		return {
+			name: packageName,
+			version: typeof packageJson.version === "string" ? packageJson.version : void 0,
+			rootPath: path.dirname(packageJsonPath),
+			packageJsonPath,
+			packageJson
+		};
+	} catch {
+		return;
+	}
+}
+function getTailwindPackageInfo(options) {
+	const cwd = options.tailwind.cwd ?? options.projectRoot;
+	return (options.tailwind.resolve?.paths?.length ? getPackageInfoFromCwd(options.tailwind.packageName, cwd) : void 0) ?? getPackageInfoSync(options.tailwind.packageName, options.tailwind.resolve);
+}
+var TailwindcssPatcher = class {
+	options;
+	packageInfo;
+	majorVersion;
+	cacheContext;
+	cacheStore;
+	collector;
+	patchMemo;
+	constructor(options = {}) {
+		this.options = normalizeOptions(options);
+		const packageInfo = getTailwindPackageInfo(this.options);
+		if (!packageInfo) throw new Error(`Unable to locate Tailwind CSS package "${this.options.tailwind.packageName}".`);
+		this.packageInfo = packageInfo;
+		this.majorVersion = resolveMajorVersionOrThrow(this.options.tailwind.versionHint, this.packageInfo.version, this.options.tailwind.packageName);
+		this.cacheContext = createCacheContextDescriptor(this.options, this.packageInfo, this.majorVersion);
+		this.cacheStore = new CacheStore(this.options.cache, this.cacheContext);
+		this.collector = createCollector(this.packageInfo, this.options, this.majorVersion, () => this.createPatchSnapshot());
+	}
+	async patch() {
+		const snapshot = this.collector.getPatchSnapshot();
+		if (this.patchMemo && this.patchMemo.snapshot === snapshot) return this.patchMemo.result;
+		const result = await this.collector.patch();
+		this.patchMemo = {
+			result,
+			snapshot: this.collector.getPatchSnapshot()
+		};
+		return result;
+	}
+	async getPatchStatus() {
+		return this.collector.getPatchStatus();
+	}
+	getContexts() {
+		return this.collector.getContexts();
+	}
+	createPatchSnapshot() {
+		const entries = [];
+		const pushSnapshot = (filePath) => {
+			if (!fs.pathExistsSync(filePath)) {
+				entries.push(`${filePath}:missing`);
+				return;
+			}
+			const stat = fs.statSync(filePath);
+			entries.push(`${filePath}:${stat.size}:${Math.trunc(stat.mtimeMs)}`);
+		};
+		if (this.options.features.exposeContext.enabled && (this.majorVersion === 2 || this.majorVersion === 3)) if (this.majorVersion === 2) {
+			pushSnapshot(path.resolve(this.packageInfo.rootPath, "lib/jit/processTailwindFeatures.js"));
+			pushSnapshot(path.resolve(this.packageInfo.rootPath, "lib/jit/index.js"));
+		} else {
+			pushSnapshot(path.resolve(this.packageInfo.rootPath, "lib/processTailwindFeatures.js"));
+			const pluginPath = ["lib/plugin.js", "lib/index.js"].map((file) => path.resolve(this.packageInfo.rootPath, file)).find((file) => fs.pathExistsSync(file));
+			if (pluginPath) pushSnapshot(pluginPath);
+		}
+		if (this.options.features.extendLengthUnits?.enabled) {
+			if (this.majorVersion === 3) {
+				const target = this.options.features.extendLengthUnits.lengthUnitsFilePath ?? "lib/util/dataTypes.js";
+				pushSnapshot(path.resolve(this.packageInfo.rootPath, target));
+			} else if (this.majorVersion === 4) {
+				const distDir = path.resolve(this.packageInfo.rootPath, "dist");
+				if (fs.pathExistsSync(distDir)) {
+					const chunkNames = fs.readdirSync(distDir).filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs")).sort();
+					for (const chunkName of chunkNames) pushSnapshot(path.join(distDir, chunkName));
+				} else entries.push(`${distDir}:missing`);
+			}
+		}
+		return entries.join("|");
+	}
+	async collectClassSet() {
+		if (this.majorVersion === 4) return this.collector.collectClassSet();
+		return collectClassesFromContexts(this.getContexts(), this.options.filter);
+	}
+	async runTailwindBuildIfNeeded() {
+		await this.collector.runTailwindBuildIfNeeded?.();
+	}
+	debugCacheRead(meta) {
+		if (meta.hit) {
+			logger.debug(`[cache] hit fingerprint=${meta.fingerprint?.slice(0, 12) ?? "n/a"} schema=${meta.schemaVersion ?? "legacy"} ${meta.details.join("; ")}`);
+			return;
+		}
+		logger.debug(`[cache] miss reason=${meta.reason} fingerprint=${meta.fingerprint?.slice(0, 12) ?? "n/a"} schema=${meta.schemaVersion ?? "legacy"} ${meta.details.join("; ")}`);
+	}
+	async mergeWithCache(set) {
+		if (!this.options.cache.enabled) return set;
+		const { data: existing, meta } = await this.cacheStore.readWithMeta();
+		this.debugCacheRead(meta);
+		if (this.options.cache.strategy === "merge") {
+			for (const value of existing) set.add(value);
+			const writeTarget = this.areSetsEqual(existing, set) ? void 0 : await this.cacheStore.write(set);
+			if (writeTarget) logger.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
+		} else if (set.size > 0) {
+			const writeTarget = this.areSetsEqual(existing, set) ? void 0 : await this.cacheStore.write(set);
+			if (writeTarget) logger.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
+		} else return existing;
+		return set;
+	}
+	mergeWithCacheSync(set) {
+		if (!this.options.cache.enabled) return set;
+		const { data: existing, meta } = this.cacheStore.readWithMetaSync();
+		this.debugCacheRead(meta);
+		if (this.options.cache.strategy === "merge") {
+			for (const value of existing) set.add(value);
+			const writeTarget = this.areSetsEqual(existing, set) ? void 0 : this.cacheStore.writeSync(set);
+			if (writeTarget) logger.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
+		} else if (set.size > 0) {
+			const writeTarget = this.areSetsEqual(existing, set) ? void 0 : this.cacheStore.writeSync(set);
+			if (writeTarget) logger.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
+		} else return existing;
+		return set;
+	}
+	areSetsEqual(a, b) {
+		if (a.size !== b.size) return false;
+		for (const value of a) if (!b.has(value)) return false;
+		return true;
+	}
+	async getClassSet() {
+		await this.runTailwindBuildIfNeeded();
+		const set = await this.collectClassSet();
+		return this.mergeWithCache(set);
+	}
+	getClassSetSync() {
+		if (this.majorVersion === 4) throw new Error("getClassSetSync is not supported for Tailwind CSS v4 projects. Use getClassSet instead.");
+		const contexts = this.getContexts();
+		const set = collectClassesFromContexts(contexts, this.options.filter);
+		const merged = this.mergeWithCacheSync(set);
+		if (contexts.length === 0 && merged.size === 0) return;
+		return merged;
+	}
+	async extract(options) {
+		const shouldWrite = options?.write ?? this.options.output.enabled;
+		const classSet = await this.getClassSet();
+		const classList = Array.from(classSet);
+		const result = {
+			classList,
+			classSet
+		};
+		if (!shouldWrite || !this.options.output.file) return result;
+		const target = path.resolve(this.options.output.file);
+		await fs.ensureDir(path.dirname(target));
+		if (this.options.output.format === "json") {
+			const spaces = typeof this.options.output.pretty === "number" ? this.options.output.pretty : void 0;
+			await fs.writeJSON(target, classList, { spaces });
+		} else await fs.writeFile(target, `${classList.join("\n")}\n`, "utf8");
+		logger.success(`Tailwind CSS class list saved to ${target.replace(process.cwd(), ".")}`);
+		return {
+			...result,
+			filename: target
+		};
+	}
+	async clearCache(options) {
+		const result = await this.cacheStore.clear(options);
+		logger.debug(`[cache] clear scope=${result.scope} contexts=${result.contextsRemoved} entries=${result.entriesRemoved} files=${result.filesRemoved}`);
+		return result;
+	}
+	extractValidCandidates = extractValidCandidates;
+	async collectContentTokens(options) {
+		return extractProjectCandidatesWithPositions({
+			cwd: options?.cwd ?? this.options.projectRoot,
+			sources: options?.sources ?? this.options.tailwind.v4?.sources ?? []
+		});
+	}
+	async collectContentTokensByFile(options) {
+		const collectContentOptions = {
+			...options?.cwd === void 0 ? {} : { cwd: options.cwd },
+			...options?.sources === void 0 ? {} : { sources: options.sources }
+		};
+		return groupTokensByFile(await this.collectContentTokens(collectContentOptions), {
+			...options?.key === void 0 ? {} : { key: options.key },
+			...options?.stripAbsolutePaths === void 0 ? {} : { stripAbsolutePaths: options.stripAbsolutePaths }
+		});
+	}
+};
+//#endregion
+//#region src/commands/migration-report.ts
+const MIGRATION_REPORT_KIND = "tw-patch-migrate-report";
+const MIGRATION_REPORT_SCHEMA_VERSION = 1;
+function assertMigrationReportCompatibility(report, reportFile) {
+	if (report.reportKind !== void 0 && report.reportKind !== "tw-patch-migrate-report") throw new Error(`Unsupported report kind "${report.reportKind}" in ${reportFile}.`);
+	if (report.schemaVersion !== void 0 && (!Number.isInteger(report.schemaVersion) || report.schemaVersion > 1)) throw new Error(`Unsupported report schema version "${String(report.schemaVersion)}" in ${reportFile}. Current supported version is 1.`);
+}
+//#endregion
+//#region src/commands/migration-aggregation.ts
+function createMigrationAggregationState() {
+	return {
+		scannedFiles: 0,
+		changedFiles: 0,
+		writtenFiles: 0,
+		backupsWritten: 0,
+		unchangedFiles: 0,
+		missingFiles: 0,
+		entries: []
+	};
+}
+function collectMigrationExecutionResult(state, result) {
+	if (result.missing) {
+		state.missingFiles += 1;
+		return;
+	}
+	state.scannedFiles += 1;
+	state.entries.push(result.entry);
+	if (result.changed) {
+		state.changedFiles += 1;
+		if (result.wrote) state.writtenFiles += 1;
+		if (result.backupWritten) state.backupsWritten += 1;
+	} else state.unchangedFiles += 1;
+}
+function buildMigrationReport(state, context) {
+	const { cwd, dryRun, rollbackOnError, backupDirectory, toolName, toolVersion, generatedAt = (/* @__PURE__ */ new Date()).toISOString() } = context;
+	return {
+		reportKind: MIGRATION_REPORT_KIND,
+		schemaVersion: 1,
+		generatedAt,
+		tool: {
+			name: toolName,
+			version: toolVersion
+		},
+		cwd,
+		dryRun,
+		rollbackOnError,
+		...backupDirectory ? { backupDirectory } : {},
+		scannedFiles: state.scannedFiles,
+		changedFiles: state.changedFiles,
+		writtenFiles: state.writtenFiles,
+		backupsWritten: state.backupsWritten,
+		unchangedFiles: state.unchangedFiles,
+		missingFiles: state.missingFiles,
+		entries: state.entries
+	};
+}
+//#endregion
+//#region src/commands/migration-source.ts
+const ROOT_LEGACY_KEYS = [
+	"cwd",
+	"overwrite",
+	"tailwind",
+	"features",
+	"output",
+	"applyPatches"
+];
+function getPropertyKeyName(property) {
+	if (!property.computed && t.isIdentifier(property.key)) return property.key.name;
+	if (t.isStringLiteral(property.key)) return property.key.value;
+}
+function findObjectProperty(objectExpression, name) {
+	for (const property of objectExpression.properties) {
+		if (!t.isObjectProperty(property)) continue;
+		if (getPropertyKeyName(property) === name) return property;
+	}
+}
+function findObjectExpressionProperty(objectExpression, name) {
+	const property = findObjectProperty(objectExpression, name);
+	if (!property) return;
+	if (t.isObjectExpression(property.value)) return property.value;
+}
+function removeObjectProperty(objectExpression, property) {
+	const index = objectExpression.properties.indexOf(property);
+	if (index >= 0) objectExpression.properties.splice(index, 1);
+}
+function hasObjectProperty(objectExpression, name) {
+	return findObjectProperty(objectExpression, name) !== void 0;
+}
+function keyAsIdentifier(name) {
+	return t.identifier(name);
+}
+function mergeObjectProperties(target, source) {
+	let changed = false;
+	for (const sourceProperty of source.properties) {
+		if (t.isSpreadElement(sourceProperty)) {
+			target.properties.push(sourceProperty);
+			changed = true;
+			continue;
+		}
+		const sourceKey = getPropertyKeyName(sourceProperty);
+		if (!sourceKey) {
+			target.properties.push(sourceProperty);
+			changed = true;
+			continue;
+		}
+		if (hasObjectProperty(target, sourceKey)) continue;
+		target.properties.push(sourceProperty);
+		changed = true;
+	}
+	return changed;
+}
+function moveProperty(objectExpression, from, to, changes, scope) {
+	const source = findObjectProperty(objectExpression, from);
+	if (!source) return false;
+	const target = findObjectProperty(objectExpression, to);
+	if (!target) {
+		source.key = keyAsIdentifier(to);
+		source.computed = false;
+		source.shorthand = false;
+		changes.add(`${scope}.${from} -> ${scope}.${to}`);
+		return true;
+	}
+	if (t.isObjectExpression(source.value) && t.isObjectExpression(target.value)) {
+		if (mergeObjectProperties(target.value, source.value)) changes.add(`${scope}.${from} merged into ${scope}.${to}`);
+	}
+	removeObjectProperty(objectExpression, source);
+	changes.add(`${scope}.${from} removed (preferred ${scope}.${to})`);
+	return true;
+}
+function migrateExtractOptions(extract, changes, scope) {
+	let changed = false;
+	changed = moveProperty(extract, "enabled", "write", changes, scope) || changed;
+	changed = moveProperty(extract, "stripUniversalSelector", "removeUniversalSelector", changes, scope) || changed;
+	return changed;
+}
+function migrateTailwindOptions(tailwindcss, changes, scope) {
+	let changed = false;
+	changed = moveProperty(tailwindcss, "package", "packageName", changes, scope) || changed;
+	changed = moveProperty(tailwindcss, "legacy", "v2", changes, scope) || changed;
+	changed = moveProperty(tailwindcss, "classic", "v3", changes, scope) || changed;
+	changed = moveProperty(tailwindcss, "next", "v4", changes, scope) || changed;
+	return changed;
+}
+function migrateApplyOptions(apply, changes, scope) {
+	return moveProperty(apply, "exportContext", "exposeContext", changes, scope);
+}
+function ensureObjectExpressionProperty(objectExpression, name, changes, scope) {
+	const existing = findObjectProperty(objectExpression, name);
+	if (existing) return t.isObjectExpression(existing.value) ? existing.value : void 0;
+	const value = t.objectExpression([]);
+	objectExpression.properties.push(t.objectProperty(keyAsIdentifier(name), value));
+	changes.add(`${scope}.${name} created`);
+	return value;
+}
+function moveOverwriteToApply(objectExpression, changes, scope) {
+	const overwrite = findObjectProperty(objectExpression, "overwrite");
+	if (!overwrite) return false;
+	const apply = ensureObjectExpressionProperty(objectExpression, "apply", changes, scope);
+	if (!apply) return false;
+	if (!hasObjectProperty(apply, "overwrite")) {
+		apply.properties.push(t.objectProperty(keyAsIdentifier("overwrite"), overwrite.value));
+		changes.add(`${scope}.overwrite -> ${scope}.apply.overwrite`);
+	}
+	removeObjectProperty(objectExpression, overwrite);
+	return true;
+}
+function hasAnyRootLegacyKeys(objectExpression) {
+	return ROOT_LEGACY_KEYS.some((key) => hasObjectProperty(objectExpression, key));
+}
+function migrateOptionObject(objectExpression, scope, changes) {
+	let changed = false;
+	changed = moveProperty(objectExpression, "cwd", "projectRoot", changes, scope) || changed;
+	changed = moveProperty(objectExpression, "tailwind", "tailwindcss", changes, scope) || changed;
+	changed = moveProperty(objectExpression, "features", "apply", changes, scope) || changed;
+	changed = moveProperty(objectExpression, "applyPatches", "apply", changes, scope) || changed;
+	changed = moveProperty(objectExpression, "output", "extract", changes, scope) || changed;
+	changed = moveOverwriteToApply(objectExpression, changes, scope) || changed;
+	const extract = findObjectExpressionProperty(objectExpression, "extract");
+	if (extract) changed = migrateExtractOptions(extract, changes, scope) || changed;
+	const tailwindcss = findObjectExpressionProperty(objectExpression, "tailwindcss");
+	if (tailwindcss) changed = migrateTailwindOptions(tailwindcss, changes, scope) || changed;
+	const apply = findObjectExpressionProperty(objectExpression, "apply");
+	if (apply) changed = migrateApplyOptions(apply, changes, scope) || changed;
+	return changed;
+}
+function unwrapExpression(node) {
+	let current = node;
+	while (t.isTSAsExpression(current) || t.isTSSatisfiesExpression(current) || t.isTSTypeAssertion(current) || t.isParenthesizedExpression(current)) current = current.expression;
+	return current;
+}
+function resolveObjectExpressionFromExpression(expression) {
+	const unwrapped = unwrapExpression(expression);
+	if (t.isObjectExpression(unwrapped)) return unwrapped;
+	if (t.isCallExpression(unwrapped)) {
+		const [firstArg] = unwrapped.arguments;
+		if (!firstArg || !t.isExpression(firstArg)) return;
+		const firstArgUnwrapped = unwrapExpression(firstArg);
+		if (t.isObjectExpression(firstArgUnwrapped)) return firstArgUnwrapped;
+	}
+}
+function resolveObjectExpressionFromProgram(program, name) {
+	for (const statement of program.body) {
+		if (!t.isVariableDeclaration(statement)) continue;
+		for (const declaration of statement.declarations) {
+			if (!t.isIdentifier(declaration.id) || declaration.id.name !== name || !declaration.init) continue;
+			const objectExpression = resolveObjectExpressionFromExpression(declaration.init);
+			if (objectExpression) return objectExpression;
+		}
+	}
+}
+function resolveRootConfigObjectExpression(program) {
+	for (const statement of program.body) {
+		if (!t.isExportDefaultDeclaration(statement)) continue;
+		const declaration = statement.declaration;
+		if (t.isIdentifier(declaration)) return resolveObjectExpressionFromProgram(program, declaration.name);
+		const objectExpression = resolveObjectExpressionFromExpression(declaration);
+		if (objectExpression) return objectExpression;
+	}
+}
+function migrateConfigSource(source) {
+	const ast = parse(source, {
+		sourceType: "module",
+		plugins: ["typescript", "jsx"]
+	});
+	const root = resolveRootConfigObjectExpression(ast.program);
+	if (!root) return {
+		changed: false,
+		code: source,
+		changes: []
+	};
+	const changes = /* @__PURE__ */ new Set();
+	let changed = false;
+	const registry = findObjectExpressionProperty(root, "registry");
+	if (registry) changed = migrateOptionObject(registry, "registry", changes) || changed;
+	const patch = findObjectExpressionProperty(root, "patch");
+	if (patch) changed = migrateOptionObject(patch, "patch", changes) || changed;
+	if (hasAnyRootLegacyKeys(root)) changed = migrateOptionObject(root, "root", changes) || changed;
+	if (!changed) return {
+		changed: false,
+		code: source,
+		changes: []
+	};
+	const generated = generate(ast, { comments: true }).code;
+	return {
+		changed: true,
+		code: source.endsWith("\n") ? `${generated}\n` : generated,
+		changes: [...changes]
+	};
+}
+//#endregion
+//#region src/commands/migration-target-files.ts
+const DEFAULT_CONFIG_FILENAMES = [
+	"tailwindcss-patch.config.ts",
+	"tailwindcss-patch.config.js",
+	"tailwindcss-patch.config.mjs",
+	"tailwindcss-patch.config.cjs",
+	"tailwindcss-mangle.config.ts",
+	"tailwindcss-mangle.config.js",
+	"tailwindcss-mangle.config.mjs",
+	"tailwindcss-mangle.config.cjs"
+];
+const DEFAULT_CONFIG_FILENAME_SET = new Set(DEFAULT_CONFIG_FILENAMES);
+const DEFAULT_WORKSPACE_IGNORED_DIRS = new Set([
+	".git",
+	".idea",
+	".turbo",
+	".vscode",
+	".yarn",
+	"coverage",
+	"dist",
+	"node_modules",
+	"tmp"
+]);
+function resolveTargetFiles(cwd, files) {
+	const candidates = files && files.length > 0 ? files : [...DEFAULT_CONFIG_FILENAMES];
+	const resolved = /* @__PURE__ */ new Set();
+	for (const file of candidates) resolved.add(path.resolve(cwd, file));
+	return [...resolved];
+}
+async function collectWorkspaceConfigFiles(cwd, maxDepth) {
+	const files = /* @__PURE__ */ new Set();
+	const queue = [{
+		dir: cwd,
+		depth: 0
+	}];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (!current) continue;
+		const { dir, depth } = current;
+		let entries;
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			const absolutePath = path.resolve(dir, entry.name);
+			if (entry.isFile() && DEFAULT_CONFIG_FILENAME_SET.has(entry.name)) {
+				files.add(absolutePath);
+				continue;
+			}
+			if (!entry.isDirectory()) continue;
+			if (DEFAULT_WORKSPACE_IGNORED_DIRS.has(entry.name)) continue;
+			if (depth >= maxDepth) continue;
+			queue.push({
+				dir: absolutePath,
+				depth: depth + 1
+			});
+		}
+	}
+	return [...files].sort((a, b) => a.localeCompare(b));
+}
+function resolveBackupRelativePath(cwd, file) {
+	const relative = path.relative(cwd, file);
+	if (relative.startsWith("..") || path.isAbsolute(relative)) {
+		const sanitized = file.replace(/[:/\\]+/g, "_");
+		return path.join("__external__", `${sanitized}.bak`);
+	}
+	return `${relative}.bak`;
+}
+function normalizePattern(pattern) {
+	return pattern.replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
+}
+function globToRegExp(globPattern) {
+	const normalized = normalizePattern(globPattern);
+	let pattern = "";
+	for (let i = 0; i < normalized.length; i += 1) {
+		const char = normalized[i];
+		if (char === "*") {
+			if (normalized[i + 1] === "*") {
+				pattern += ".*";
+				i += 1;
+			} else pattern += "[^/]*";
+			continue;
+		}
+		if (char === "?") {
+			pattern += "[^/]";
+			continue;
+		}
+		if ("\\^$+?.()|{}[]".includes(char)) {
+			pattern += `\\${char}`;
+			continue;
+		}
+		pattern += char;
+	}
+	return new RegExp(`^${pattern}$`);
+}
+function toPatternList(patterns) {
+	if (!patterns || patterns.length === 0) return [];
+	return patterns.map((pattern) => pattern.trim()).filter(Boolean).map(globToRegExp);
+}
+function normalizeFileForPattern(file, cwd) {
+	const relative = path.relative(cwd, file);
+	if (!relative.startsWith("..") && !path.isAbsolute(relative)) return relative.replace(/\\/g, "/");
+	return file.replace(/\\/g, "/");
+}
+function filterTargetFiles(targetFiles, cwd, include, exclude) {
+	const includePatterns = toPatternList(include);
+	const excludePatterns = toPatternList(exclude);
+	if (includePatterns.length === 0 && excludePatterns.length === 0) return targetFiles;
+	return targetFiles.filter((file) => {
+		const normalized = normalizeFileForPattern(file, cwd);
+		if (!(includePatterns.length === 0 || includePatterns.some((pattern) => pattern.test(normalized)))) return false;
+		return !excludePatterns.some((pattern) => pattern.test(normalized));
+	});
+}
+//#endregion
+//#region src/commands/migration-file-executor.ts
+async function rollbackWrittenEntries(wroteEntries) {
+	let rollbackCount = 0;
+	for (const written of [...wroteEntries].reverse()) try {
+		await fs.writeFile(written.file, written.source, "utf8");
+		written.entry.written = false;
+		written.entry.rolledBack = true;
+		rollbackCount += 1;
+	} catch {}
+	return rollbackCount;
+}
+async function executeMigrationFile(options) {
+	const { cwd, file, dryRun, rollbackOnError, backupDirectory, wroteEntries } = options;
+	if (!await fs.pathExists(file)) return {
+		missing: true,
+		changed: false,
+		wrote: false,
+		backupWritten: false
+	};
+	const source = await fs.readFile(file, "utf8");
+	const migrated = migrateConfigSource(source);
+	const entry = {
+		file,
+		changed: migrated.changed,
+		written: false,
+		rolledBack: false,
+		changes: migrated.changes
+	};
+	if (!migrated.changed || dryRun) return {
+		missing: false,
+		changed: migrated.changed,
+		wrote: false,
+		backupWritten: false,
+		entry
+	};
+	let backupWritten = false;
+	try {
+		if (backupDirectory) {
+			const backupRelativePath = resolveBackupRelativePath(cwd, file);
+			const backupFile = path.resolve(backupDirectory, backupRelativePath);
+			await fs.ensureDir(path.dirname(backupFile));
+			await fs.writeFile(backupFile, source, "utf8");
+			entry.backupFile = backupFile;
+			backupWritten = true;
+		}
+		await fs.writeFile(file, migrated.code, "utf8");
+		entry.written = true;
+		wroteEntries.push({
+			file,
+			source,
+			entry
+		});
+		return {
+			missing: false,
+			changed: true,
+			wrote: true,
+			backupWritten,
+			entry
+		};
+	} catch (error) {
+		const rollbackCount = rollbackOnError && wroteEntries.length > 0 ? await rollbackWrittenEntries(wroteEntries) : 0;
+		const reason = error instanceof Error ? error.message : String(error);
+		const rollbackHint = rollbackOnError && rollbackCount > 0 ? ` Rolled back ${rollbackCount} previously written file(s).` : "";
+		throw new Error(`Failed to write migrated config "${file}": ${reason}.${rollbackHint}`);
+	}
+}
+async function restoreConfigEntries(entries, dryRun) {
+	let scannedEntries = 0;
+	let restorableEntries = 0;
+	let restoredFiles = 0;
+	let missingBackups = 0;
+	let skippedEntries = 0;
+	const restored = [];
+	for (const entry of entries) {
+		scannedEntries += 1;
+		const targetFile = entry.file ? path.resolve(entry.file) : void 0;
+		const backupFile = entry.backupFile ? path.resolve(entry.backupFile) : void 0;
+		if (!targetFile || !backupFile) {
+			skippedEntries += 1;
+			continue;
+		}
+		restorableEntries += 1;
+		if (!await fs.pathExists(backupFile)) {
+			missingBackups += 1;
+			continue;
+		}
+		if (!dryRun) {
+			const backupContent = await fs.readFile(backupFile, "utf8");
+			await fs.ensureDir(path.dirname(targetFile));
+			await fs.writeFile(targetFile, backupContent, "utf8");
+		}
+		restoredFiles += 1;
+		restored.push(targetFile);
+	}
+	return {
+		scannedEntries,
+		restorableEntries,
+		restoredFiles,
+		missingBackups,
+		skippedEntries,
+		restored
+	};
+}
+//#endregion
+//#region src/commands/migration-report-loader.ts
+async function loadMigrationReportForRestore(reportFile) {
+	const report = await fs.readJSON(reportFile);
+	assertMigrationReportCompatibility(report, reportFile);
+	return {
+		...report.reportKind === void 0 ? {} : { reportKind: report.reportKind },
+		...report.schemaVersion === void 0 ? {} : { schemaVersion: report.schemaVersion },
+		entries: Array.isArray(report.entries) ? report.entries : []
+	};
+}
+//#endregion
+//#region src/commands/migration-target-resolver.ts
+async function resolveMigrationTargetFiles(options) {
+	const { cwd, files, workspace, maxDepth, include, exclude } = options;
+	const resolvedMaxDepth = maxDepth ?? 6;
+	return filterTargetFiles(files && files.length > 0 ? resolveTargetFiles(cwd, files) : workspace ? await collectWorkspaceConfigFiles(cwd, resolvedMaxDepth) : resolveTargetFiles(cwd), cwd, include, exclude);
+}
+//#endregion
+//#region src/commands/migrate-config.ts
+async function migrateConfigFiles(options) {
+	const cwd = path.resolve(options.cwd);
+	const dryRun = options.dryRun ?? false;
+	const rollbackOnError = options.rollbackOnError ?? true;
+	const backupDirectory = options.backupDir ? path.resolve(cwd, options.backupDir) : void 0;
+	const targetFiles = await resolveMigrationTargetFiles({
+		cwd,
+		files: options.files,
+		workspace: options.workspace,
+		maxDepth: options.maxDepth,
+		include: options.include,
+		exclude: options.exclude
+	});
+	const aggregation = createMigrationAggregationState();
+	const wroteEntries = [];
+	for (const file of targetFiles) collectMigrationExecutionResult(aggregation, await executeMigrationFile({
+		cwd,
+		file,
+		dryRun,
+		rollbackOnError,
+		wroteEntries,
+		...backupDirectory ? { backupDirectory } : {}
+	}));
+	return buildMigrationReport(aggregation, {
+		cwd,
+		dryRun,
+		rollbackOnError,
+		...backupDirectory ? { backupDirectory } : {},
+		toolName: pkgName,
+		toolVersion: pkgVersion
+	});
+}
+async function restoreConfigFiles(options) {
+	const cwd = path.resolve(options.cwd);
+	const dryRun = options.dryRun ?? false;
+	const strict = options.strict ?? false;
+	const reportFile = path.resolve(cwd, options.reportFile);
+	const report = await loadMigrationReportForRestore(reportFile);
+	const { scannedEntries, restorableEntries, restoredFiles, missingBackups, skippedEntries, restored } = await restoreConfigEntries(report.entries, dryRun);
+	if (strict && missingBackups > 0) throw new Error(`Restore failed: ${missingBackups} backup file(s) missing in report ${reportFile}.`);
+	return {
+		cwd,
+		reportFile,
+		...report.reportKind === void 0 ? {} : { reportKind: report.reportKind },
+		...report.schemaVersion === void 0 ? {} : { reportSchemaVersion: report.schemaVersion },
+		dryRun,
+		strict,
+		scannedEntries,
+		restorableEntries,
+		restoredFiles,
+		missingBackups,
+		skippedEntries,
+		restored
+	};
+}
+//#endregion
+//#region src/commands/types.ts
+const tailwindcssPatchCommands = [
+	"install",
+	"extract",
+	"tokens",
+	"init",
+	"migrate",
+	"restore",
+	"validate",
+	"status"
+];
+//#endregion
+//#region src/commands/validate.ts
+const VALIDATE_EXIT_CODES = {
+	OK: 0,
+	REPORT_INCOMPATIBLE: 21,
+	MISSING_BACKUPS: 22,
+	IO_ERROR: 23,
+	UNKNOWN_ERROR: 24
+};
+const VALIDATE_FAILURE_REASONS = [
+	"report-incompatible",
+	"missing-backups",
+	"io-error",
+	"unknown-error"
+];
+const IO_ERROR_CODES = new Set([
+	"ENOENT",
+	"EACCES",
+	"EPERM",
+	"EISDIR",
+	"ENOTDIR",
+	"EMFILE",
+	"ENFILE"
+]);
+function isNodeError(error) {
+	return !!error && typeof error === "object" && ("code" in error || "message" in error);
+}
+function classifyValidateError(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	if (message.startsWith("Unsupported report kind") || message.startsWith("Unsupported report schema version")) return {
+		reason: "report-incompatible",
+		exitCode: VALIDATE_EXIT_CODES.REPORT_INCOMPATIBLE,
+		message
+	};
+	if (message.startsWith("Restore failed:")) return {
+		reason: "missing-backups",
+		exitCode: VALIDATE_EXIT_CODES.MISSING_BACKUPS,
+		message
+	};
+	if (isNodeError(error) && typeof error.code === "string" && IO_ERROR_CODES.has(error.code)) return {
+		reason: "io-error",
+		exitCode: VALIDATE_EXIT_CODES.IO_ERROR,
+		message
+	};
+	return {
+		reason: "unknown-error",
+		exitCode: VALIDATE_EXIT_CODES.UNKNOWN_ERROR,
+		message
+	};
+}
+var ValidateCommandError = class extends Error {
+	reason;
+	exitCode;
+	constructor(summary, options) {
+		super(summary.message, options);
+		this.name = "ValidateCommandError";
+		this.reason = summary.reason;
+		this.exitCode = summary.exitCode;
+	}
+};
+//#endregion
+export { extractTailwindV4InlineSourceCandidates as C, normalizeOptions as D, loadWorkspaceConfigModule as E, CacheStore as O, loadTailwindV4DesignSystem as S, loadPatchOptionsForWorkspace as T, extractRawCandidates as _, tailwindcssPatchCommands as a, groupTokensByFile as b, MIGRATION_REPORT_KIND as c, getPatchStatusReport as d, runTailwindBuild as f, extractProjectCandidatesWithPositions as g, collectClassesFromTailwindV4 as h, classifyValidateError as i, logger as k, MIGRATION_REPORT_SCHEMA_VERSION as l, collectClassesFromContexts as m, VALIDATE_FAILURE_REASONS as n, migrateConfigFiles as o, loadRuntimeContexts as p, ValidateCommandError as r, restoreConfigFiles as s, VALIDATE_EXIT_CODES as t, TailwindcssPatcher as u, extractRawCandidatesWithPositions as v, resolveValidTailwindV4Candidates as w, compileTailwindV4Source as x, extractValidCandidates as y };