tailwindcss-patch 9.5.1 → 10.0.0

package/dist/validate-C8oLv32F.js

@@ -1,3282 +0,0 @@
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
-let node_module = require("node:module");
-let node_process = require("node:process");
-node_process = __toESM(node_process);
-let fs_extra = require("fs-extra");
-fs_extra = __toESM(fs_extra);
-let local_pkg = require("local-pkg");
-let pathe = require("pathe");
-pathe = __toESM(pathe);
-let semver = require("semver");
-let node_crypto = require("node:crypto");
-let consola = require("consola");
-let node_url = require("node:url");
-let _tailwindcss_mangle_engine = require("@tailwindcss-mangle/engine");
-let _babel_types = require("@babel/types");
-_babel_types = __toESM(_babel_types);
-let _babel_generator = require("@babel/generator");
-_babel_generator = __toESM(_babel_generator);
-let _babel_traverse = require("@babel/traverse");
-_babel_traverse = __toESM(_babel_traverse);
-let _babel_parser = require("@babel/parser");
-let postcss = require("postcss");
-postcss = __toESM(postcss);
-let tailwindcss_config = require("tailwindcss-config");
-//#region package.json
-var version = "9.5.1";
-//#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 pathe.default.normalize(value).replaceAll("\\", "/");
-}
-function resolveRealpathSyncSafe(value) {
-	const resolved = pathe.default.resolve(value);
-	try {
-		return normalizePathname(fs_extra.default.realpathSync(resolved));
-	} catch {
-		return normalizePathname(resolved);
-	}
-}
-function resolveFileMtimeMsSync(value) {
-	if (!value) return;
-	try {
-		const stat = fs_extra.default.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 = pathe.default.isAbsolute(configured) ? configured : pathe.default.resolve(baseDir, configured);
-		if (fs_extra.default.pathExistsSync(absolute)) return resolveRealpathSyncSafe(absolute);
-	}
-	for (const candidate of DEFAULT_TAILWIND_CONFIG_FILES) {
-		const absolute = pathe.default.resolve(baseDir, candidate);
-		if (fs_extra.default.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 (0, node_crypto.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(node_process.default.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 = (0, consola.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 {
-	options;
-	context;
-	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_extra.default.ensureDir(this.options.dir);
-	}
-	ensureDirSync() {
-		fs_extra.default.ensureDirSync(this.options.dir);
-	}
-	createTempPath() {
-		const uniqueSuffix = `${node_process.default.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-		return `${this.options.path}.${uniqueSuffix}.tmp`;
-	}
-	async replaceCacheFile(tempPath) {
-		try {
-			await fs_extra.default.rename(tempPath, this.options.path);
-			return true;
-		} catch (error) {
-			if (isErrnoException(error) && (error.code === "EEXIST" || error.code === "EPERM")) {
-				try {
-					await fs_extra.default.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_extra.default.rename(tempPath, this.options.path);
-				return true;
-			}
-			throw error;
-		}
-	}
-	replaceCacheFileSync(tempPath) {
-		try {
-			fs_extra.default.renameSync(tempPath, this.options.path);
-			return true;
-		} catch (error) {
-			if (isErrnoException(error) && (error.code === "EEXIST" || error.code === "EPERM")) {
-				try {
-					fs_extra.default.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_extra.default.renameSync(tempPath, this.options.path);
-				return true;
-			}
-			throw error;
-		}
-	}
-	async cleanupTempFile(tempPath) {
-		try {
-			await fs_extra.default.remove(tempPath);
-		} catch {}
-	}
-	cleanupTempFileSync(tempPath) {
-		try {
-			fs_extra.default.removeSync(tempPath);
-		} catch {}
-	}
-	async delay(ms) {
-		await new Promise((resolve) => setTimeout(resolve, ms));
-	}
-	async acquireLock() {
-		await fs_extra.default.ensureDir(this.options.dir);
-		const maxAttempts = 40;
-		for (let attempt = 0; attempt < maxAttempts; attempt++) try {
-			await fs_extra.default.writeFile(this.lockPath, `${node_process.default.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_extra.default.stat(this.lockPath);
-				if (Date.now() - stat.mtimeMs > 3e4) {
-					await fs_extra.default.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_extra.default.removeSync(this.lockPath);
-			} catch {}
-			return;
-		}
-		return fs_extra.default.remove(this.lockPath).catch(() => void 0);
-	}
-	acquireLockSync() {
-		fs_extra.default.ensureDirSync(this.options.dir);
-		const maxAttempts = 40;
-		for (let attempt = 0; attempt < maxAttempts; attempt++) try {
-			fs_extra.default.writeFileSync(this.lockPath, `${node_process.default.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_extra.default.statSync(this.lockPath);
-				if (Date.now() - stat.mtimeMs > 3e4) {
-					fs_extra.default.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_extra.default.pathExists(this.options.path)) return { kind: "empty" };
-			const payload = await fs_extra.default.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_extra.default.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_extra.default.remove(this.options.path);
-			} catch (cleanupError) {
-				logger.error("Failed to clean up invalid cache file", cleanupError);
-			}
-			return { kind: "invalid" };
-		}
-	}
-	readParsedCacheFileSync(cleanupInvalid) {
-		try {
-			if (!fs_extra.default.pathExistsSync(this.options.path)) return { kind: "empty" };
-			const payload = fs_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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_extra.default.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 = pathe.default.resolve(value);
-	try {
-		return pathe.default.normalize(fs_extra.default.realpathSync(resolved));
-	} catch {
-		return pathe.default.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 = pathe.default.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 ? pathe.default.resolve(cache.dir) : pathe.default.resolve(cwd, "node_modules/.cache", pkgName);
-		file = cache.file ?? file;
-		strategy = cache.strategy ?? strategy;
-		driver = normalizeCacheDriver(cache.driver);
-	}
-	const filename = pathe.default.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 ? pathe.default.resolve(v4.base) : void 0;
-	const base = configuredBase ?? fallbackBase;
-	const resolveV4Path = (value) => pathe.default.isAbsolute(value) ? pathe.default.resolve(value) : pathe.default.resolve(fallbackBase, value);
-	const cssSources = Array.isArray(v4?.cssSources) ? v4.cssSources.filter((source) => typeof source?.css === "string").map((source) => ({
-		css: source.css,
-		...source.base === void 0 ? {} : { base: resolveV4Path(source.base) },
-		...source.file === void 0 ? {} : { file: resolveV4Path(source.file) },
-		...source.dependencies === void 0 ? {} : { dependencies: source.dependencies.filter(Boolean).map(resolveV4Path) }
-	})) : [];
-	const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => pathe.default.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 },
-		cssSources,
-		cssEntries,
-		sources,
-		hasUserDefinedSources,
-		bareArbitraryValues: v4?.bareArbitraryValues === true ? {} : typeof v4?.bareArbitraryValues === "object" && v4.bareArbitraryValues !== null ? { ...v4.bareArbitraryValues } : false
-	};
-}
-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 ? pathe.default.resolve(options.projectRoot) : node_process.default.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 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((0, node_url.pathToFileURL)(pathe.default.resolve(__dirname, "../../../config/src/index.ts")).href);
-	});
-	return configModulePromise;
-}
-async function loadWorkspaceDefu() {
-	if (!defuPromise) defuPromise = Promise.resolve().then(() => require("./dist-wp0o36Ns.js")).then((mod) => mod.defu).catch(async (error) => {
-		if (!isMissingSharedModuleError(error)) throw error;
-		return (await import((0, node_url.pathToFileURL)(pathe.default.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/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 pathe.default.isAbsolute(value) ? value : pathe.default.resolve(options.projectRoot, value);
-	};
-	const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
-	const resolvedDefaultBase = toAbsolute(v4Options.base) ?? node_process.default.cwd();
-	const resolveSources = (base) => {
-		if (!v4Options.sources?.length) return;
-		return v4Options.sources.map((source) => ({
-			base: source.base ?? base,
-			pattern: source.pattern,
-			negated: source.negated
-		}));
-	};
-	const addCandidates = async (extractOptions) => {
-		const candidates = await (0, _tailwindcss_mangle_engine.extractValidCandidates)(extractOptions);
-		for (const candidate of candidates) if (options.filter(candidate)) set.add(candidate);
-	};
-	if (v4Options.cssSources.length > 0) for (const source of v4Options.cssSources) {
-		const sourceFile = toAbsolute(source.file);
-		const sourceBase = toAbsolute(source.base) ?? (sourceFile ? pathe.default.dirname(sourceFile) : resolvedDefaultBase);
-		const designSystemBases = resolvedConfiguredBase && resolvedConfiguredBase !== sourceBase ? [sourceBase, resolvedConfiguredBase] : [sourceBase];
-		const sources = resolveSources(sourceBase);
-		const firstBase = designSystemBases[0] ?? sourceBase;
-		await addCandidates({
-			cwd: options.projectRoot,
-			base: firstBase,
-			baseFallbacks: designSystemBases.slice(1),
-			css: source.css,
-			...v4Options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: v4Options.bareArbitraryValues },
-			...sources === void 0 ? {} : { sources }
-		});
-	}
-	if (v4Options.cssEntries.length > 0) for (const entry of v4Options.cssEntries) {
-		const filePath = pathe.default.isAbsolute(entry) ? entry : pathe.default.resolve(options.projectRoot, entry);
-		if (!await fs_extra.default.pathExists(filePath)) continue;
-		const css = await fs_extra.default.readFile(filePath, "utf8");
-		const entryDir = pathe.default.dirname(filePath);
-		const designSystemBases = resolvedConfiguredBase && resolvedConfiguredBase !== entryDir ? [entryDir, resolvedConfiguredBase] : [entryDir];
-		const sources = resolveSources(resolvedConfiguredBase ?? entryDir);
-		const firstBase = designSystemBases[0] ?? entryDir;
-		await addCandidates({
-			cwd: options.projectRoot,
-			base: firstBase,
-			baseFallbacks: designSystemBases.slice(1),
-			css,
-			...v4Options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: v4Options.bareArbitraryValues },
-			...sources === void 0 ? {} : { sources }
-		});
-	}
-	else if (v4Options.cssSources.length === 0) {
-		const baseForCss = resolvedConfiguredBase ?? resolvedDefaultBase;
-		const sources = resolveSources(baseForCss);
-		await addCandidates({
-			cwd: options.projectRoot,
-			base: baseForCss,
-			...v4Options.bareArbitraryValues === void 0 ? {} : { bareArbitraryValues: v4Options.bareArbitraryValues },
-			...v4Options.css === void 0 ? {} : { css: v4Options.css },
-			...sources === void 0 ? {} : { sources }
-		});
-	}
-	return set;
-}
-//#endregion
-//#region src/runtime/context-registry.ts
-const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
-function resolveRuntimeEntry(packageInfo, majorVersion) {
-	const root = packageInfo.rootPath;
-	if (majorVersion === 2) {
-		const jitIndex = pathe.default.join(root, "lib/jit/index.js");
-		if (fs_extra.default.existsSync(jitIndex)) return jitIndex;
-	} else if (majorVersion === 3) {
-		const plugin = pathe.default.join(root, "lib/plugin.js");
-		const index = pathe.default.join(root, "lib/index.js");
-		if (fs_extra.default.existsSync(plugin)) return plugin;
-		if (fs_extra.default.existsSync(index)) return index;
-	}
-}
-function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
-	if (majorVersion === 4) return [];
-	const entry = resolveRuntimeEntry(packageInfo, majorVersion);
-	if (!entry) return [];
-	const moduleExports = require$1(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(_babel_generator.default);
-const traverse = _interopDefaultCompat(_babel_traverse.default);
-//#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 _babel_types.memberExpression(_babel_types.identifier("exports"), _babel_types.identifier(property));
-	return _babel_types.memberExpression(_babel_types.identifier("exports"), _babel_types.stringLiteral(property), true);
-}
-function transformProcessTailwindFeaturesReturnContextV2(content) {
-	const ast = (0, _babel_parser.parse)(content, { sourceType: "unambiguous" });
-	let hasPatched = false;
-	traverse(ast, { FunctionDeclaration(path) {
-		const node = path.node;
-		if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !_babel_types.isReturnStatement(node.body.body[0])) return;
-		const returnStatement = node.body.body[0];
-		if (!_babel_types.isFunctionExpression(returnStatement.argument)) return;
-		const body = returnStatement.argument.body.body;
-		const lastStatement = body[body.length - 1];
-		const alreadyReturnsContext = Boolean(_babel_types.isReturnStatement(lastStatement) && _babel_types.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context");
-		hasPatched = alreadyReturnsContext;
-		if (!alreadyReturnsContext) body.push(_babel_types.returnStatement(_babel_types.identifier("context")));
-	} });
-	return {
-		code: hasPatched ? content : generate$1(ast).code,
-		hasPatched
-	};
-}
-function transformPostcssPluginV2(content, options) {
-	const refIdentifier = _babel_types.identifier(toIdentifierName$1(options.refProperty));
-	const exportMember = createExportsMember(options.refProperty);
-	const valueMember = _babel_types.memberExpression(refIdentifier, _babel_types.identifier("value"));
-	const ast = (0, _babel_parser.parse)(content);
-	let hasPatched = false;
-	traverse(ast, {
-		Program(path) {
-			const program = path.node;
-			const index = program.body.findIndex((statement) => {
-				return _babel_types.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 && _babel_types.isVariableDeclaration(previous) && previous.declarations.length === 1 && (() => {
-				const declaration = previous.declarations[0];
-				return Boolean(declaration && _babel_types.isIdentifier(declaration.id) && declaration.id.name === refIdentifier.name);
-			})());
-			const alreadyAssignsExports = Boolean(beforePrevious && _babel_types.isExpressionStatement(beforePrevious) && _babel_types.isAssignmentExpression(beforePrevious.expression) && _babel_types.isMemberExpression(beforePrevious.expression.left) && _babel_types.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, _babel_types.variableDeclaration("var", [_babel_types.variableDeclarator(refIdentifier, _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("value"), _babel_types.arrayExpression())]))]), _babel_types.expressionStatement(_babel_types.assignmentExpression("=", exportMember, refIdentifier)));
-		},
-		FunctionDeclaration(path) {
-			if (hasPatched) return;
-			const fn = path.node;
-			if (fn.id?.name !== "_default") return;
-			if (fn.body.body.length !== 1 || !_babel_types.isReturnStatement(fn.body.body[0])) return;
-			const returnStatement = fn.body.body[0];
-			if (!_babel_types.isCallExpression(returnStatement.argument) || !_babel_types.isMemberExpression(returnStatement.argument.callee) || !_babel_types.isArrayExpression(returnStatement.argument.callee.object)) return;
-			const fnExpression = returnStatement.argument.callee.object.elements[1];
-			if (!fnExpression || !_babel_types.isFunctionExpression(fnExpression)) return;
-			const statements = fnExpression.body.body;
-			if (_babel_types.isExpressionStatement(statements[0]) && _babel_types.isAssignmentExpression(statements[0].expression) && _babel_types.isNumericLiteral(statements[0].expression.right)) {
-				hasPatched = true;
-				return;
-			}
-			const lastStatement = statements[statements.length - 1];
-			if (lastStatement && _babel_types.isExpressionStatement(lastStatement)) statements[statements.length - 1] = _babel_types.expressionStatement(_babel_types.callExpression(_babel_types.memberExpression(valueMember, _babel_types.identifier("push")), [lastStatement.expression]));
-			const index = statements.findIndex((statement) => _babel_types.isIfStatement(statement));
-			if (index > -1) {
-				const ifStatement = statements[index];
-				if (_babel_types.isBlockStatement(ifStatement.consequent) && ifStatement.consequent.body[1] && _babel_types.isForOfStatement(ifStatement.consequent.body[1])) {
-					const forOf = ifStatement.consequent.body[1];
-					if (_babel_types.isBlockStatement(forOf.body) && forOf.body.body.length === 1) {
-						const nestedIf = forOf.body.body[0];
-						if (nestedIf && _babel_types.isIfStatement(nestedIf) && _babel_types.isBlockStatement(nestedIf.consequent) && nestedIf.consequent.body.length === 1 && _babel_types.isExpressionStatement(nestedIf.consequent.body[0])) nestedIf.consequent.body[0] = _babel_types.expressionStatement(_babel_types.callExpression(_babel_types.memberExpression(valueMember, _babel_types.identifier("push")), [nestedIf.consequent.body[0].expression]));
-					}
-				}
-			}
-			statements.unshift(_babel_types.expressionStatement(_babel_types.assignmentExpression("=", _babel_types.memberExpression(valueMember, _babel_types.identifier("length")), _babel_types.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 = _babel_types.memberExpression(_babel_types.identifier("module"), _babel_types.identifier("exports"));
-	if (IDENTIFIER_RE.test(property)) return _babel_types.memberExpression(object, _babel_types.identifier(property));
-	return _babel_types.memberExpression(object, _babel_types.stringLiteral(property), true);
-}
-function transformProcessTailwindFeaturesReturnContext(content) {
-	const ast = (0, _babel_parser.parse)(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 (!_babel_types.isReturnStatement(returnStatement) || !_babel_types.isFunctionExpression(returnStatement.argument)) return;
-		const body = returnStatement.argument.body.body;
-		const lastStatement = body[body.length - 1];
-		const alreadyReturnsContext = Boolean(_babel_types.isReturnStatement(lastStatement) && _babel_types.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context");
-		hasPatched = alreadyReturnsContext;
-		if (!alreadyReturnsContext) body.push(_babel_types.returnStatement(_babel_types.identifier("context")));
-	} });
-	return {
-		code: hasPatched ? content : generate$1(ast).code,
-		hasPatched
-	};
-}
-function transformPostcssPlugin(content, { refProperty }) {
-	const ast = (0, _babel_parser.parse)(content);
-	const refIdentifier = _babel_types.identifier(toIdentifierName(refProperty));
-	const moduleExportsMember = createModuleExportsMember(refProperty);
-	const valueMember = _babel_types.memberExpression(refIdentifier, _babel_types.identifier("value"));
-	let hasPatched = false;
-	traverse(ast, {
-		Program(path) {
-			const program = path.node;
-			const index = program.body.findIndex((statement) => {
-				return _babel_types.isExpressionStatement(statement) && _babel_types.isAssignmentExpression(statement.expression) && _babel_types.isMemberExpression(statement.expression.left) && _babel_types.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 && _babel_types.isVariableDeclaration(previousStatement) && previousStatement.declarations.length === 1 && (() => {
-				const declaration = previousStatement.declarations[0];
-				return Boolean(declaration && _babel_types.isIdentifier(declaration.id) && declaration.id.name === refIdentifier.name);
-			})());
-			const alreadyAssignsModuleExports = Boolean(_babel_types.isExpressionStatement(lastStatement) && _babel_types.isAssignmentExpression(lastStatement.expression) && _babel_types.isMemberExpression(lastStatement.expression.left) && _babel_types.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, _babel_types.variableDeclaration("const", [_babel_types.variableDeclarator(refIdentifier, _babel_types.objectExpression([_babel_types.objectProperty(_babel_types.identifier("value"), _babel_types.arrayExpression())]))]));
-			if (!alreadyAssignsModuleExports) program.body.push(_babel_types.expressionStatement(_babel_types.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 || !_babel_types.isReturnStatement(returnStatement) || !_babel_types.isObjectExpression(returnStatement.argument)) return;
-			const properties = returnStatement.argument.properties;
-			if (properties.length !== 2) return;
-			const pluginsProperty = properties.find((prop) => _babel_types.isObjectProperty(prop) && _babel_types.isIdentifier(prop.key) && prop.key.name === "plugins");
-			if (!pluginsProperty || !_babel_types.isObjectProperty(pluginsProperty) || !_babel_types.isCallExpression(pluginsProperty.value) || !_babel_types.isMemberExpression(pluginsProperty.value.callee) || !_babel_types.isArrayExpression(pluginsProperty.value.callee.object)) return;
-			const targetPlugin = pluginsProperty.value.callee.object.elements[1];
-			if (!targetPlugin || !_babel_types.isFunctionExpression(targetPlugin)) return;
-			const statements = targetPlugin.body.body;
-			const last = statements[statements.length - 1];
-			if (last && _babel_types.isExpressionStatement(last)) statements[statements.length - 1] = _babel_types.expressionStatement(_babel_types.callExpression(_babel_types.memberExpression(valueMember, _babel_types.identifier("push")), [last.expression]));
-			const index = statements.findIndex((s) => _babel_types.isIfStatement(s));
-			if (index > -1) {
-				const ifStatement = statements[index];
-				if (_babel_types.isBlockStatement(ifStatement.consequent)) {
-					const [, second] = ifStatement.consequent.body;
-					if (second && _babel_types.isForOfStatement(second) && _babel_types.isBlockStatement(second.body)) {
-						const bodyStatement = second.body.body[0];
-						if (bodyStatement && _babel_types.isIfStatement(bodyStatement) && _babel_types.isBlockStatement(bodyStatement.consequent) && bodyStatement.consequent.body.length === 1 && _babel_types.isExpressionStatement(bodyStatement.consequent.body[0])) bodyStatement.consequent.body[0] = _babel_types.expressionStatement(_babel_types.callExpression(_babel_types.memberExpression(valueMember, _babel_types.identifier("push")), [bodyStatement.consequent.body[0].expression]));
-					}
-				}
-			}
-			statements.unshift(_babel_types.expressionStatement(_babel_types.assignmentExpression("=", _babel_types.memberExpression(valueMember, _babel_types.identifier("length")), _babel_types.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_extra.default.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 = pathe.default.resolve(rootDir, processFileRelative);
-		if (fs_extra.default.existsSync(processFilePath)) {
-			const { code, hasPatched } = transformProcessTailwindFeaturesReturnContext(fs_extra.default.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_extra.default.existsSync(pathe.default.resolve(rootDir, candidate)));
-		if (pluginRelative) {
-			const pluginPath = pathe.default.resolve(rootDir, pluginRelative);
-			const { code, hasPatched } = transformPostcssPlugin(fs_extra.default.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 = pathe.default.resolve(rootDir, processFileRelative);
-		if (fs_extra.default.existsSync(processFilePath)) {
-			const { code, hasPatched } = transformProcessTailwindFeaturesReturnContextV2(fs_extra.default.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 = pathe.default.resolve(rootDir, pluginRelative);
-		if (fs_extra.default.existsSync(pluginPath)) {
-			const { code, hasPatched } = transformPostcssPluginV2(fs_extra.default.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 = (0, _babel_parser.parse)(content);
-	let arrayRef;
-	let changed = false;
-	traverse(ast, { Identifier(path) {
-		if (path.node.name === variableName && _babel_types.isVariableDeclarator(path.parent) && _babel_types.isArrayExpression(path.parent.init)) {
-			arrayRef = path.parent.init;
-			const existing = new Set(path.parent.init.elements.map((element) => _babel_types.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 (_babel_types.isStringLiteral(element)) return _babel_types.stringLiteral(element.value);
-					return element;
-				});
-				path.parent.init.elements.push(_babel_types.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 = pathe.default.resolve(rootDir, opts.lengthUnitsFilePath);
-	if (!fs_extra.default.existsSync(dataTypesFilePath)) return {
-		changed: false,
-		code: void 0
-	};
-	const content = fs_extra.default.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 ? pathe.default.resolve(opts.destPath) : dataTypesFilePath;
-			fs_extra.default.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 = pathe.default.resolve(rootDir, "dist");
-	if (!fs_extra.default.existsSync(distDir)) return {
-		files: [],
-		changed: false
-	};
-	const chunkNames = fs_extra.default.readdirSync(distDir).filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs"));
-	const pattern = /\[\s*["']cm["'],\s*["']mm["'],[\w,"']+\]/;
-	const candidates = chunkNames.map((chunkName) => {
-		const file = pathe.default.join(distDir, chunkName);
-		const code = fs_extra.default.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 = (0, _babel_parser.parse)(match[0], { sourceType: "unambiguous" });
-		traverse(ast, { ArrayExpression(path) {
-			for (const unit of opts.units) {
-				if (path.node.elements.some((element) => _babel_types.isStringLiteral(element) && element.value === unit)) {
-					item.hasPatched = true;
-					return;
-				}
-				path.node.elements.push(_babel_types.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_extra.default.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 (0, node_module.createRequire)(pathe.default.join(cwd, "package.json"));
-}
-function resolveModuleEntry(id, moduleRequire) {
-	return pathe.default.isAbsolute(id) ? id : moduleRequire.resolve(id);
-}
-function resolvePackageRootFromEntry(entry) {
-	let current = pathe.default.dirname(entry);
-	while (current && current !== pathe.default.dirname(current)) {
-		const packageJsonPath = pathe.default.join(current, "package.json");
-		if (fs_extra.default.pathExistsSync(packageJsonPath)) return current;
-		current = pathe.default.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 = pathe.default.join(root, "lib/lib/sharedState.js");
-		if (!fs_extra.default.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 = pathe.default.join(root, candidate);
-			if (!fs_extra.default.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 && pathe.default.isAbsolute(options.config)) return options.config;
-	const result = await (0, tailwindcss_config.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 (0, postcss.default)([moduleRequire(pluginName)({ config: configPath })]).process("@import 'tailwindcss';", { from: void 0 });
-	return (0, postcss.default)([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 = (0, _babel_parser.parse)(content);
-	let found = false;
-	let missingUnits = [];
-	traverse(ast, { Identifier(path) {
-		if (path.node.name === variableName && _babel_types.isVariableDeclarator(path.parent) && _babel_types.isArrayExpression(path.parent.init)) {
-			found = true;
-			const existing = new Set(path.parent.init.elements.map((element) => _babel_types.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 = pathe.default.resolve(packageInfo.rootPath, relative);
-		if (!fs_extra.default.existsSync(filePath)) {
-			checks.push({
-				relative,
-				exists: false,
-				patched: false
-			});
-			return;
-		}
-		const { hasPatched } = transform(fs_extra.default.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_extra.default.existsSync(pathe.default.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 = pathe.default.resolve(rootDir, lengthUnitsFilePath);
-	const files = fs_extra.default.existsSync(target) ? [pathe.default.relative(rootDir, target)] : [];
-	if (!fs_extra.default.existsSync(target)) return {
-		name: "extendLengthUnits",
-		status: "not-applied",
-		reason: `missing ${lengthUnitsFilePath}`,
-		files
-	};
-	const { found, missingUnits } = inspectLengthUnitsArray(fs_extra.default.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 = pathe.default.resolve(rootDir, "dist");
-	if (!fs_extra.default.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) => pathe.default.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) => pathe.default.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 {
-	packageInfo;
-	options;
-	majorVersion;
-	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 {
-	snapshotFactory;
-	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 = (0, semver.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, resolvePaths = []) {
-	try {
-		const packageJsonPath = (0, node_module.createRequire)(pathe.default.join(cwd, "package.json")).resolve(`${packageName}/package.json`, { paths: resolvePaths });
-		const packageJson = fs_extra.default.readJSONSync(packageJsonPath);
-		return {
-			name: packageName,
-			version: typeof packageJson.version === "string" ? packageJson.version : void 0,
-			rootPath: pathe.default.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, options.tailwind.resolve.paths) : void 0) ?? (0, local_pkg.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_extra.default.pathExistsSync(filePath)) {
-				entries.push(`${filePath}:missing`);
-				return;
-			}
-			const stat = fs_extra.default.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(pathe.default.resolve(this.packageInfo.rootPath, "lib/jit/processTailwindFeatures.js"));
-			pushSnapshot(pathe.default.resolve(this.packageInfo.rootPath, "lib/jit/index.js"));
-		} else {
-			pushSnapshot(pathe.default.resolve(this.packageInfo.rootPath, "lib/processTailwindFeatures.js"));
-			const pluginPath = ["lib/plugin.js", "lib/index.js"].map((file) => pathe.default.resolve(this.packageInfo.rootPath, file)).find((file) => fs_extra.default.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(pathe.default.resolve(this.packageInfo.rootPath, target));
-			} else if (this.majorVersion === 4) {
-				const distDir = pathe.default.resolve(this.packageInfo.rootPath, "dist");
-				if (fs_extra.default.pathExistsSync(distDir)) {
-					const chunkNames = fs_extra.default.readdirSync(distDir).filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs")).sort();
-					for (const chunkName of chunkNames) pushSnapshot(pathe.default.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 = pathe.default.resolve(this.options.output.file);
-		await fs_extra.default.ensureDir(pathe.default.dirname(target));
-		if (this.options.output.format === "json") {
-			const spaces = typeof this.options.output.pretty === "number" ? this.options.output.pretty : void 0;
-			await fs_extra.default.writeJSON(target, classList, { spaces });
-		} else await fs_extra.default.writeFile(target, `${classList.join("\n")}\n`, "utf8");
-		logger.success(`Tailwind CSS class list saved to ${target.replace(node_process.default.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 = _tailwindcss_mangle_engine.extractValidCandidates;
-	async collectContentTokens(options) {
-		return (0, _tailwindcss_mangle_engine.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 (0, _tailwindcss_mangle_engine.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 && _babel_types.isIdentifier(property.key)) return property.key.name;
-	if (_babel_types.isStringLiteral(property.key)) return property.key.value;
-}
-function findObjectProperty(objectExpression, name) {
-	for (const property of objectExpression.properties) {
-		if (!_babel_types.isObjectProperty(property)) continue;
-		if (getPropertyKeyName(property) === name) return property;
-	}
-}
-function findObjectExpressionProperty(objectExpression, name) {
-	const property = findObjectProperty(objectExpression, name);
-	if (!property) return;
-	if (_babel_types.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 _babel_types.identifier(name);
-}
-function mergeObjectProperties(target, source) {
-	let changed = false;
-	for (const sourceProperty of source.properties) {
-		if (_babel_types.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 (_babel_types.isObjectExpression(source.value) && _babel_types.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 _babel_types.isObjectExpression(existing.value) ? existing.value : void 0;
-	const value = _babel_types.objectExpression([]);
-	objectExpression.properties.push(_babel_types.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(_babel_types.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 (_babel_types.isTSAsExpression(current) || _babel_types.isTSSatisfiesExpression(current) || _babel_types.isTSTypeAssertion(current) || _babel_types.isParenthesizedExpression(current)) current = current.expression;
-	return current;
-}
-function resolveObjectExpressionFromExpression(expression) {
-	const unwrapped = unwrapExpression(expression);
-	if (_babel_types.isObjectExpression(unwrapped)) return unwrapped;
-	if (_babel_types.isCallExpression(unwrapped)) {
-		const [firstArg] = unwrapped.arguments;
-		if (!firstArg || !_babel_types.isExpression(firstArg)) return;
-		const firstArgUnwrapped = unwrapExpression(firstArg);
-		if (_babel_types.isObjectExpression(firstArgUnwrapped)) return firstArgUnwrapped;
-	}
-}
-function resolveObjectExpressionFromProgram(program, name) {
-	for (const statement of program.body) {
-		if (!_babel_types.isVariableDeclaration(statement)) continue;
-		for (const declaration of statement.declarations) {
-			if (!_babel_types.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 (!_babel_types.isExportDefaultDeclaration(statement)) continue;
-		const declaration = statement.declaration;
-		if (_babel_types.isIdentifier(declaration)) return resolveObjectExpressionFromProgram(program, declaration.name);
-		const objectExpression = resolveObjectExpressionFromExpression(declaration);
-		if (objectExpression) return objectExpression;
-	}
-}
-function migrateConfigSource(source) {
-	const ast = (0, _babel_parser.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 = (0, _babel_generator.default)(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(pathe.default.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_extra.default.readdir(dir, { withFileTypes: true });
-		} catch {
-			continue;
-		}
-		for (const entry of entries) {
-			const absolutePath = pathe.default.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 = pathe.default.relative(cwd, file);
-	if (relative.startsWith("..") || pathe.default.isAbsolute(relative)) {
-		const sanitized = file.replace(/[:/\\]+/g, "_");
-		return pathe.default.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 = pathe.default.relative(cwd, file);
-	if (!relative.startsWith("..") && !pathe.default.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_extra.default.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_extra.default.pathExists(file)) return {
-		missing: true,
-		changed: false,
-		wrote: false,
-		backupWritten: false
-	};
-	const source = await fs_extra.default.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 = pathe.default.resolve(backupDirectory, backupRelativePath);
-			await fs_extra.default.ensureDir(pathe.default.dirname(backupFile));
-			await fs_extra.default.writeFile(backupFile, source, "utf8");
-			entry.backupFile = backupFile;
-			backupWritten = true;
-		}
-		await fs_extra.default.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 ? pathe.default.resolve(entry.file) : void 0;
-		const backupFile = entry.backupFile ? pathe.default.resolve(entry.backupFile) : void 0;
-		if (!targetFile || !backupFile) {
-			skippedEntries += 1;
-			continue;
-		}
-		restorableEntries += 1;
-		if (!await fs_extra.default.pathExists(backupFile)) {
-			missingBackups += 1;
-			continue;
-		}
-		if (!dryRun) {
-			const backupContent = await fs_extra.default.readFile(backupFile, "utf8");
-			await fs_extra.default.ensureDir(pathe.default.dirname(targetFile));
-			await fs_extra.default.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_extra.default.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 = pathe.default.resolve(options.cwd);
-	const dryRun = options.dryRun ?? false;
-	const rollbackOnError = options.rollbackOnError ?? true;
-	const backupDirectory = options.backupDir ? pathe.default.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 = pathe.default.resolve(options.cwd);
-	const dryRun = options.dryRun ?? false;
-	const strict = options.strict ?? false;
-	const reportFile = pathe.default.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
-Object.defineProperty(exports, "CacheStore", {
-	enumerable: true,
-	get: function() {
-		return CacheStore;
-	}
-});
-Object.defineProperty(exports, "MIGRATION_REPORT_KIND", {
-	enumerable: true,
-	get: function() {
-		return MIGRATION_REPORT_KIND;
-	}
-});
-Object.defineProperty(exports, "MIGRATION_REPORT_SCHEMA_VERSION", {
-	enumerable: true,
-	get: function() {
-		return MIGRATION_REPORT_SCHEMA_VERSION;
-	}
-});
-Object.defineProperty(exports, "TailwindcssPatcher", {
-	enumerable: true,
-	get: function() {
-		return TailwindcssPatcher;
-	}
-});
-Object.defineProperty(exports, "VALIDATE_EXIT_CODES", {
-	enumerable: true,
-	get: function() {
-		return VALIDATE_EXIT_CODES;
-	}
-});
-Object.defineProperty(exports, "VALIDATE_FAILURE_REASONS", {
-	enumerable: true,
-	get: function() {
-		return VALIDATE_FAILURE_REASONS;
-	}
-});
-Object.defineProperty(exports, "ValidateCommandError", {
-	enumerable: true,
-	get: function() {
-		return ValidateCommandError;
-	}
-});
-Object.defineProperty(exports, "__toESM", {
-	enumerable: true,
-	get: function() {
-		return __toESM;
-	}
-});
-Object.defineProperty(exports, "classifyValidateError", {
-	enumerable: true,
-	get: function() {
-		return classifyValidateError;
-	}
-});
-Object.defineProperty(exports, "collectClassesFromContexts", {
-	enumerable: true,
-	get: function() {
-		return collectClassesFromContexts;
-	}
-});
-Object.defineProperty(exports, "collectClassesFromTailwindV4", {
-	enumerable: true,
-	get: function() {
-		return collectClassesFromTailwindV4;
-	}
-});
-Object.defineProperty(exports, "getPatchStatusReport", {
-	enumerable: true,
-	get: function() {
-		return getPatchStatusReport;
-	}
-});
-Object.defineProperty(exports, "loadPatchOptionsForWorkspace", {
-	enumerable: true,
-	get: function() {
-		return loadPatchOptionsForWorkspace;
-	}
-});
-Object.defineProperty(exports, "loadRuntimeContexts", {
-	enumerable: true,
-	get: function() {
-		return loadRuntimeContexts;
-	}
-});
-Object.defineProperty(exports, "loadWorkspaceConfigModule", {
-	enumerable: true,
-	get: function() {
-		return loadWorkspaceConfigModule;
-	}
-});
-Object.defineProperty(exports, "logger", {
-	enumerable: true,
-	get: function() {
-		return logger;
-	}
-});
-Object.defineProperty(exports, "migrateConfigFiles", {
-	enumerable: true,
-	get: function() {
-		return migrateConfigFiles;
-	}
-});
-Object.defineProperty(exports, "normalizeOptions", {
-	enumerable: true,
-	get: function() {
-		return normalizeOptions;
-	}
-});
-Object.defineProperty(exports, "restoreConfigFiles", {
-	enumerable: true,
-	get: function() {
-		return restoreConfigFiles;
-	}
-});
-Object.defineProperty(exports, "runTailwindBuild", {
-	enumerable: true,
-	get: function() {
-		return runTailwindBuild;
-	}
-});
-Object.defineProperty(exports, "tailwindcssPatchCommands", {
-	enumerable: true,
-	get: function() {
-		return tailwindcssPatchCommands;
-	}
-});