tailwindcss-patch 8.6.1 → 8.7.0

package/dist/chunk-2YHCFHVA.mjs

@@ -0,0 +1,4739 @@
+// src/logger.ts
+import { createConsola } from "consola";
+var logger = createConsola();
+var logger_default = logger;
+
+// src/cache/store.ts
+import process2 from "process";
+import fs2 from "fs-extra";
+
+// src/cache/context.ts
+import { createHash } from "crypto";
+import process from "process";
+import fs from "fs-extra";
+import path from "pathe";
+
+// package.json
+var package_default = {
+  name: "tailwindcss-patch",
+  version: "8.7.0",
+  description: "patch tailwindcss for exposing context and extract classes",
+  author: "ice breaker <1324318532@qq.com>",
+  license: "MIT",
+  homepage: "https://mangle.icebreaker.top/",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/sonofmagic/tailwindcss-mangle.git",
+    directory: "packages/tailwindcss-patch"
+  },
+  bugs: {
+    url: "https://github.com/sonofmagic/tailwindcss-mangle/issues"
+  },
+  keywords: [
+    "tailwindcss",
+    "patch",
+    "extract",
+    "class"
+  ],
+  exports: {
+    ".": {
+      types: "./src/index.ts",
+      import: "./src/index.ts",
+      require: "./src/index.ts"
+    },
+    "./migration-report.schema.json": "./schema/migration-report.schema.json",
+    "./restore-result.schema.json": "./schema/restore-result.schema.json",
+    "./validate-result.schema.json": "./schema/validate-result.schema.json"
+  },
+  main: "./src/index.ts",
+  module: "./src/index.ts",
+  types: "./src/index.ts",
+  bin: {
+    "tw-patch": "dev/bin.ts",
+    "tailwindcss-patch": "dev/bin.ts"
+  },
+  files: [
+    "bin",
+    "dist",
+    "schema"
+  ],
+  scripts: {
+    dev: "tsup --watch --sourcemap",
+    build: "tsup",
+    test: "vitest run",
+    "test:dev": "vitest",
+    patch: "tsx dev/bin.ts install",
+    r0: "tsx dev/bin.ts extract",
+    r1: "tsx dev/bin.ts extract --css index.css"
+  },
+  publishConfig: {
+    access: "public",
+    registry: "https://registry.npmjs.org/",
+    bin: {
+      "tw-patch": "bin/tw-patch.js",
+      "tailwindcss-patch": "bin/tw-patch.js"
+    },
+    exports: {
+      ".": {
+        types: "./dist/index.d.ts",
+        import: "./dist/index.mjs",
+        require: "./dist/index.js"
+      },
+      "./migration-report.schema.json": "./schema/migration-report.schema.json",
+      "./restore-result.schema.json": "./schema/restore-result.schema.json",
+      "./validate-result.schema.json": "./schema/validate-result.schema.json"
+    },
+    main: "./dist/index.js",
+    module: "./dist/index.mjs",
+    types: "./dist/index.d.ts"
+  },
+  peerDependencies: {
+    tailwindcss: ">=2.0.0"
+  },
+  peerDependenciesMeta: {
+    tailwindcss: {
+      optional: true
+    }
+  },
+  dependencies: {
+    "@babel/generator": "^7.29.1",
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "@tailwindcss-mangle/config": "workspace:*",
+    "@tailwindcss/node": "^4.1.18",
+    cac: "^6.7.14",
+    consola: "^3.4.2",
+    "fs-extra": "^11.3.3",
+    "local-pkg": "^1.1.2",
+    pathe: "^2.0.3",
+    postcss: "^8.5.6",
+    semver: "^7.7.4",
+    "tailwindcss-config": "^1.1.4"
+  },
+  devDependencies: {
+    "@tailwindcss/oxide": "^4.1.18",
+    "@tailwindcss/postcss": "^4.1.18",
+    "@tailwindcss/vite": "^4.1.18",
+    tailwindcss: "catalog:tailwindcss4",
+    "tailwindcss-3": "catalog:tailwindcss3",
+    "tailwindcss-4": "catalog:tailwindcss4"
+  }
+};
+
+// src/constants.ts
+var pkgName = "tailwindcss-patch";
+var pkgVersion = package_default.version;
+
+// src/cache/types.ts
+var CACHE_SCHEMA_VERSION = 2;
+var CACHE_FINGERPRINT_VERSION = 1;
+
+// src/cache/context.ts
+var DEFAULT_TAILWIND_CONFIG_FILES = [
+  "tailwind.config.js",
+  "tailwind.config.cjs",
+  "tailwind.config.mjs",
+  "tailwind.config.ts",
+  "tailwind.config.cts",
+  "tailwind.config.mts"
+];
+function normalizePathname(value) {
+  return path.normalize(value).replaceAll("\\", "/");
+}
+function resolveRealpathSyncSafe(value) {
+  const resolved = path.resolve(value);
+  try {
+    return normalizePathname(fs.realpathSync(resolved));
+  } catch {
+    return normalizePathname(resolved);
+  }
+}
+function resolveFileMtimeMsSync(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    const stat = fs.statSync(value);
+    if (!stat.isFile()) {
+      return void 0;
+    }
+    return stat.mtimeMs;
+  } catch {
+    return void 0;
+  }
+}
+function resolveTailwindConfigPath(options, majorVersion) {
+  const tailwind = options.tailwind;
+  const baseDir = tailwind.cwd ?? options.projectRoot;
+  const configured = (() => {
+    if (majorVersion === 2 && tailwind.v2?.config) {
+      return tailwind.v2.config;
+    }
+    if (majorVersion === 3 && tailwind.v3?.config) {
+      return tailwind.v3.config;
+    }
+    return tailwind.config;
+  })();
+  if (configured) {
+    const absolute = path.isAbsolute(configured) ? configured : path.resolve(baseDir, configured);
+    if (fs.pathExistsSync(absolute)) {
+      return resolveRealpathSyncSafe(absolute);
+    }
+  }
+  for (const candidate of DEFAULT_TAILWIND_CONFIG_FILES) {
+    const absolute = path.resolve(baseDir, candidate);
+    if (fs.pathExistsSync(absolute)) {
+      return resolveRealpathSyncSafe(absolute);
+    }
+  }
+  return void 0;
+}
+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") {
+    const entries = Object.entries(input).filter(([, value]) => value !== void 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${JSON.stringify(key)}:${stableSerialize(value)}`);
+    return `{${entries.join(",")}}`;
+  }
+  return JSON.stringify(String(input));
+}
+function hash(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function toFingerprintOptions(normalized) {
+  return {
+    overwrite: normalized.overwrite,
+    output: {
+      removeUniversalSelector: normalized.output.removeUniversalSelector,
+      format: normalized.output.format
+    },
+    features: normalized.features,
+    tailwind: {
+      packageName: normalized.tailwind.packageName,
+      cwd: normalized.tailwind.cwd,
+      config: normalized.tailwind.config,
+      postcssPlugin: normalized.tailwind.postcssPlugin,
+      versionHint: normalized.tailwind.versionHint,
+      v2: normalized.tailwind.v2,
+      v3: normalized.tailwind.v3,
+      v4: normalized.tailwind.v4
+    }
+  };
+}
+function createCacheContextDescriptor(options, packageInfo, majorVersion) {
+  const projectRootRealpath = resolveRealpathSyncSafe(options.projectRoot);
+  const processCwdRealpath = resolveRealpathSyncSafe(process.cwd());
+  const cacheCwdRealpath = resolveRealpathSyncSafe(options.cache.cwd);
+  const tailwindPackageRootRealpath = resolveRealpathSyncSafe(packageInfo.rootPath);
+  const tailwindConfigPath = resolveTailwindConfigPath(options, majorVersion);
+  const tailwindConfigMtimeMs = resolveFileMtimeMsSync(tailwindConfigPath);
+  const optionsHash = hash(stableSerialize(toFingerprintOptions(options)));
+  const metadata = {
+    fingerprintVersion: CACHE_FINGERPRINT_VERSION,
+    projectRootRealpath,
+    processCwdRealpath,
+    cacheCwdRealpath,
+    ...tailwindConfigPath === void 0 ? {} : { tailwindConfigPath },
+    ...tailwindConfigMtimeMs === void 0 ? {} : { tailwindConfigMtimeMs },
+    tailwindPackageRootRealpath,
+    tailwindPackageVersion: packageInfo.version ?? "unknown",
+    patcherVersion: pkgVersion,
+    majorVersion,
+    optionsHash
+  };
+  const fingerprint = hash(stableSerialize(metadata));
+  return {
+    fingerprint,
+    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;
+}
+
+// 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 void 0;
+  }
+  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 {
+  constructor(options, context) {
+    this.options = options;
+    this.context = context;
+    this.driver = options.driver ?? "file";
+    this.lockPath = `${this.options.path}.lock`;
+  }
+  driver;
+  lockPath;
+  memoryCache = null;
+  memoryIndex = null;
+  lastReadMeta = {
+    hit: false,
+    reason: "context-not-found",
+    details: []
+  };
+  isContextAware() {
+    return this.context !== void 0;
+  }
+  createEmptyIndex() {
+    return {
+      schemaVersion: CACHE_SCHEMA_VERSION,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      contexts: {}
+    };
+  }
+  async ensureDir() {
+    await fs2.ensureDir(this.options.dir);
+  }
+  ensureDirSync() {
+    fs2.ensureDirSync(this.options.dir);
+  }
+  createTempPath() {
+    const uniqueSuffix = `${process2.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    return `${this.options.path}.${uniqueSuffix}.tmp`;
+  }
+  async replaceCacheFile(tempPath) {
+    try {
+      await fs2.rename(tempPath, this.options.path);
+      return true;
+    } catch (error) {
+      if (isErrnoException(error) && (error.code === "EEXIST" || error.code === "EPERM")) {
+        try {
+          await fs2.remove(this.options.path);
+        } catch (removeError) {
+          if (isAccessDenied(removeError)) {
+            logger_default.debug("Tailwind class cache locked or read-only, skipping update.", removeError);
+            return false;
+          }
+          if (!isErrnoException(removeError) || removeError.code !== "ENOENT") {
+            throw removeError;
+          }
+        }
+        await fs2.rename(tempPath, this.options.path);
+        return true;
+      }
+      throw error;
+    }
+  }
+  replaceCacheFileSync(tempPath) {
+    try {
+      fs2.renameSync(tempPath, this.options.path);
+      return true;
+    } catch (error) {
+      if (isErrnoException(error) && (error.code === "EEXIST" || error.code === "EPERM")) {
+        try {
+          fs2.removeSync(this.options.path);
+        } catch (removeError) {
+          if (isAccessDenied(removeError)) {
+            logger_default.debug("Tailwind class cache locked or read-only, skipping update.", removeError);
+            return false;
+          }
+          if (!isErrnoException(removeError) || removeError.code !== "ENOENT") {
+            throw removeError;
+          }
+        }
+        fs2.renameSync(tempPath, this.options.path);
+        return true;
+      }
+      throw error;
+    }
+  }
+  async cleanupTempFile(tempPath) {
+    try {
+      await fs2.remove(tempPath);
+    } catch {
+    }
+  }
+  cleanupTempFileSync(tempPath) {
+    try {
+      fs2.removeSync(tempPath);
+    } catch {
+    }
+  }
+  async delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async acquireLock() {
+    await fs2.ensureDir(this.options.dir);
+    const maxAttempts = 40;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        await fs2.writeFile(this.lockPath, `${process2.pid}
+${Date.now()}`, { flag: "wx" });
+        return true;
+      } catch (error) {
+        if (!isErrnoException(error) || error.code !== "EEXIST") {
+          logger_default.debug("Unable to acquire cache lock.", error);
+          return false;
+        }
+        try {
+          const stat = await fs2.stat(this.lockPath);
+          if (Date.now() - stat.mtimeMs > 3e4) {
+            await fs2.remove(this.lockPath);
+            continue;
+          }
+        } catch {
+        }
+        await this.delay(25);
+      }
+    }
+    logger_default.debug("Timed out while waiting for cache lock; skipping cache mutation.");
+    return false;
+  }
+  releaseLockSyncOrAsync(sync) {
+    if (sync) {
+      try {
+        fs2.removeSync(this.lockPath);
+      } catch {
+      }
+      return;
+    }
+    return fs2.remove(this.lockPath).catch(() => void 0);
+  }
+  acquireLockSync() {
+    fs2.ensureDirSync(this.options.dir);
+    const maxAttempts = 40;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        fs2.writeFileSync(this.lockPath, `${process2.pid}
+${Date.now()}`, { flag: "wx" });
+        return true;
+      } catch (error) {
+        if (!isErrnoException(error) || error.code !== "EEXIST") {
+          logger_default.debug("Unable to acquire cache lock.", error);
+          return false;
+        }
+        try {
+          const stat = fs2.statSync(this.lockPath);
+          if (Date.now() - stat.mtimeMs > 3e4) {
+            fs2.removeSync(this.lockPath);
+            continue;
+          }
+        } catch {
+        }
+        const start = Date.now();
+        while (Date.now() - start < 25) {
+        }
+      }
+    }
+    logger_default.debug("Timed out while waiting for cache lock; skipping cache mutation.");
+    return false;
+  }
+  async withFileLock(fn) {
+    const locked = await this.acquireLock();
+    if (!locked) {
+      return void 0;
+    }
+    try {
+      return await fn();
+    } finally {
+      await this.releaseLockSyncOrAsync(false);
+    }
+  }
+  withFileLockSync(fn) {
+    const locked = this.acquireLockSync();
+    if (!locked) {
+      return void 0;
+    }
+    try {
+      return fn();
+    } finally {
+      this.releaseLockSyncOrAsync(true);
+    }
+  }
+  normalizeContextEntry(value) {
+    const record = asObject(value);
+    if (!record) {
+      return void 0;
+    }
+    const values = toStringArray(record["values"]);
+    if (values.length === 0) {
+      return void 0;
+    }
+    const contextRecord = asObject(record["context"]);
+    if (!contextRecord) {
+      return void 0;
+    }
+    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 void 0;
+    }
+    const normalized = {
+      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()
+    };
+    return normalized;
+  }
+  normalizeIndexFile(payload) {
+    if (Array.isArray(payload)) {
+      return {
+        kind: "legacy",
+        data: toStringArray(payload)
+      };
+    }
+    const record = asObject(payload);
+    if (!record) {
+      return { kind: "invalid" };
+    }
+    if (record["schemaVersion"] !== CACHE_SCHEMA_VERSION) {
+      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: CACHE_SCHEMA_VERSION,
+        updatedAt: typeof record["updatedAt"] === "string" ? record["updatedAt"] : (/* @__PURE__ */ new Date(0)).toISOString(),
+        contexts
+      }
+    };
+  }
+  async readParsedCacheFile(cleanupInvalid) {
+    try {
+      if (!await fs2.pathExists(this.options.path)) {
+        return { kind: "empty" };
+      }
+      const payload = await fs2.readJSON(this.options.path);
+      const normalized = this.normalizeIndexFile(payload);
+      if (normalized.kind !== "invalid") {
+        return normalized;
+      }
+      if (cleanupInvalid) {
+        logger_default.warn("Unable to read Tailwind class cache index, removing invalid file.");
+        await fs2.remove(this.options.path);
+      }
+      return { kind: "invalid" };
+    } catch (error) {
+      if (isErrnoException(error) && error.code === "ENOENT") {
+        return { kind: "empty" };
+      }
+      logger_default.warn("Unable to read Tailwind class cache index, removing invalid file.", error);
+      if (cleanupInvalid) {
+        try {
+          await fs2.remove(this.options.path);
+        } catch (cleanupError) {
+          logger_default.error("Failed to clean up invalid cache file", cleanupError);
+        }
+      }
+      return { kind: "invalid" };
+    }
+  }
+  readParsedCacheFileSync(cleanupInvalid) {
+    try {
+      if (!fs2.pathExistsSync(this.options.path)) {
+        return { kind: "empty" };
+      }
+      const payload = fs2.readJSONSync(this.options.path);
+      const normalized = this.normalizeIndexFile(payload);
+      if (normalized.kind !== "invalid") {
+        return normalized;
+      }
+      if (cleanupInvalid) {
+        logger_default.warn("Unable to read Tailwind class cache index, removing invalid file.");
+        fs2.removeSync(this.options.path);
+      }
+      return { kind: "invalid" };
+    } catch (error) {
+      if (isErrnoException(error) && error.code === "ENOENT") {
+        return { kind: "empty" };
+      }
+      logger_default.warn("Unable to read Tailwind class cache index, removing invalid file.", error);
+      if (cleanupInvalid) {
+        try {
+          fs2.removeSync(this.options.path);
+        } catch (cleanupError) {
+          logger_default.error("Failed to clean up invalid cache file", cleanupError);
+        }
+      }
+      return { kind: "invalid" };
+    }
+  }
+  findProjectMatch(index) {
+    if (!this.context) {
+      return void 0;
+    }
+    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 fs2.writeJSON(tempPath, index);
+      const replaced = await this.replaceCacheFile(tempPath);
+      if (replaced) {
+        return this.options.path;
+      }
+      await this.cleanupTempFile(tempPath);
+      return void 0;
+    } catch (error) {
+      await this.cleanupTempFile(tempPath);
+      logger_default.error("Unable to persist Tailwind class cache", error);
+      return void 0;
+    }
+  }
+  writeIndexFileSync(index) {
+    const tempPath = this.createTempPath();
+    try {
+      this.ensureDirSync();
+      fs2.writeJSONSync(tempPath, index);
+      const replaced = this.replaceCacheFileSync(tempPath);
+      if (replaced) {
+        return this.options.path;
+      }
+      this.cleanupTempFileSync(tempPath);
+      return void 0;
+    } catch (error) {
+      this.cleanupTempFileSync(tempPath);
+      logger_default.error("Unable to persist Tailwind class cache", error);
+      return void 0;
+    }
+  }
+  async write(data) {
+    if (!this.options.enabled) {
+      return void 0;
+    }
+    if (this.driver === "noop") {
+      return void 0;
+    }
+    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 fs2.writeJSON(tempPath, Array.from(data));
+        const replaced = await this.replaceCacheFile(tempPath);
+        if (replaced) {
+          return this.options.path;
+        }
+        await this.cleanupTempFile(tempPath);
+        return void 0;
+      } catch (error) {
+        await this.cleanupTempFile(tempPath);
+        logger_default.error("Unable to persist Tailwind class cache", error);
+        return void 0;
+      }
+    }
+    const result = 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);
+    });
+    return result;
+  }
+  writeSync(data) {
+    if (!this.options.enabled) {
+      return void 0;
+    }
+    if (this.driver === "noop") {
+      return void 0;
+    }
+    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();
+        fs2.writeJSONSync(tempPath, Array.from(data));
+        const replaced = this.replaceCacheFileSync(tempPath);
+        if (replaced) {
+          return this.options.path;
+        }
+        this.cleanupTempFileSync(tempPath);
+        return void 0;
+      } catch (error) {
+        this.cleanupTempFileSync(tempPath);
+        logger_default.error("Unable to persist Tailwind class cache", error);
+        return void 0;
+      }
+    }
+    const result = 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);
+    });
+    return result;
+  }
+  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: CACHE_SCHEMA_VERSION,
+            details: ["no in-memory cache index for current context"]
+          }
+        };
+      }
+      const entry2 = index.contexts[this.context.fingerprint];
+      if (entry2) {
+        return {
+          data: new Set(entry2.values),
+          meta: {
+            hit: true,
+            reason: "hit",
+            fingerprint: this.context.fingerprint,
+            schemaVersion: CACHE_SCHEMA_VERSION,
+            details: ["memory cache hit"]
+          }
+        };
+      }
+      const projectMatch2 = this.findProjectMatch(index);
+      if (projectMatch2 && this.context) {
+        const [, matchedEntry] = projectMatch2;
+        return {
+          data: /* @__PURE__ */ new Set(),
+          meta: {
+            hit: false,
+            reason: "context-mismatch",
+            fingerprint: this.context.fingerprint,
+            schemaVersion: CACHE_SCHEMA_VERSION,
+            details: explainContextMismatch(this.context.metadata, matchedEntry.context)
+          }
+        };
+      }
+      return {
+        data: /* @__PURE__ */ new Set(),
+        meta: {
+          hit: false,
+          reason: "context-not-found",
+          fingerprint: this.context.fingerprint,
+          schemaVersion: CACHE_SCHEMA_VERSION,
+          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((entry2) => entry2.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: CACHE_SCHEMA_VERSION,
+            details: ["no in-memory cache index for current context"]
+          }
+        };
+      }
+      const entry2 = index.contexts[this.context.fingerprint];
+      if (entry2) {
+        return {
+          data: new Set(entry2.values),
+          meta: {
+            hit: true,
+            reason: "hit",
+            fingerprint: this.context.fingerprint,
+            schemaVersion: CACHE_SCHEMA_VERSION,
+            details: ["memory cache hit"]
+          }
+        };
+      }
+      const projectMatch2 = this.findProjectMatch(index);
+      if (projectMatch2 && this.context) {
+        const [, matchedEntry] = projectMatch2;
+        return {
+          data: /* @__PURE__ */ new Set(),
+          meta: {
+            hit: false,
+            reason: "context-mismatch",
+            fingerprint: this.context.fingerprint,
+            schemaVersion: CACHE_SCHEMA_VERSION,
+            details: explainContextMismatch(this.context.metadata, matchedEntry.context)
+          }
+        };
+      }
+      return {
+        data: /* @__PURE__ */ new Set(),
+        meta: {
+          hit: false,
+          reason: "context-not-found",
+          fingerprint: this.context.fingerprint,
+          schemaVersion: CACHE_SCHEMA_VERSION,
+          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((entry2) => entry2.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 entriesRemoved2 = 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: entriesRemoved2,
+          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
+      };
+    }
+    const result = 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 fs2.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 fs2.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];
+      const remain = Object.keys(parsed.data.contexts).length;
+      if (remain === 0) {
+        await fs2.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
+      };
+    });
+    return result ?? {
+      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 entriesRemoved2 = 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: entriesRemoved2,
+          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
+      };
+    }
+    const result = 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);
+        fs2.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);
+        fs2.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];
+      const remain = Object.keys(parsed.data.contexts).length;
+      if (remain === 0) {
+        fs2.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
+      };
+    });
+    return result ?? {
+      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 void 0;
+    }
+    return {
+      ...parsed.data,
+      contexts: Object.fromEntries(Object.entries(parsed.data.contexts).map(([key, value]) => [key, cloneEntry(value)]))
+    };
+  }
+};
+
+// src/extraction/candidate-extractor.ts
+import { promises as fs3 } from "fs";
+import process3 from "process";
+import path2 from "pathe";
+async function importNode() {
+  return import("@tailwindcss/node");
+}
+async function importOxide() {
+  return import("@tailwindcss/oxide");
+}
+async function loadDesignSystem(css, bases) {
+  const uniqueBases = Array.from(new Set(bases.filter(Boolean)));
+  if (uniqueBases.length === 0) {
+    throw new Error("No base directories provided for Tailwind CSS design system.");
+  }
+  const { __unstable__loadDesignSystem } = await importNode();
+  let lastError;
+  for (const base of uniqueBases) {
+    try {
+      return await __unstable__loadDesignSystem(css, { base });
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  if (lastError instanceof Error) {
+    throw lastError;
+  }
+  throw new Error("Failed to load Tailwind CSS design system.");
+}
+async function extractRawCandidatesWithPositions(content, extension = "html") {
+  const { Scanner } = await importOxide();
+  const scanner = new Scanner({});
+  const result = scanner.getCandidatesWithPositions({ content, extension });
+  return result.map(({ candidate, position }) => ({
+    rawCandidate: candidate,
+    start: position,
+    end: position + candidate.length
+  }));
+}
+async function extractRawCandidates(sources) {
+  const { Scanner } = await importOxide();
+  const scanner = new Scanner(sources === void 0 ? {} : { sources });
+  return scanner.scan();
+}
+async function extractValidCandidates(options) {
+  const providedOptions = options ?? {};
+  const defaultCwd = providedOptions.cwd ?? process3.cwd();
+  const base = providedOptions.base ?? defaultCwd;
+  const baseFallbacks = providedOptions.baseFallbacks ?? [];
+  const css = providedOptions.css ?? '@import "tailwindcss";';
+  const sources = (providedOptions.sources ?? [
+    {
+      base: defaultCwd,
+      pattern: "**/*",
+      negated: false
+    }
+  ]).map((source) => ({
+    base: source.base ?? defaultCwd,
+    pattern: source.pattern,
+    negated: source.negated
+  }));
+  const designSystem = await loadDesignSystem(css, [base, ...baseFallbacks]);
+  const candidates = await extractRawCandidates(sources);
+  const parsedCandidates = candidates.filter(
+    (rawCandidate) => designSystem.parseCandidate(rawCandidate).length > 0
+  );
+  if (parsedCandidates.length === 0) {
+    return parsedCandidates;
+  }
+  const cssByCandidate = designSystem.candidatesToCss(parsedCandidates);
+  const validCandidates = [];
+  for (let index = 0; index < parsedCandidates.length; index++) {
+    const candidate = parsedCandidates[index];
+    if (candidate === void 0) {
+      continue;
+    }
+    const css2 = cssByCandidate[index];
+    if (typeof css2 === "string" && css2.trim().length > 0) {
+      validCandidates.push(candidate);
+    }
+  }
+  return validCandidates;
+}
+function normalizeSources(sources, cwd) {
+  const baseSources = sources?.length ? sources : [
+    {
+      base: cwd,
+      pattern: "**/*",
+      negated: false
+    }
+  ];
+  return baseSources.map((source) => ({
+    base: source.base ?? cwd,
+    pattern: source.pattern,
+    negated: source.negated
+  }));
+}
+function buildLineOffsets(content) {
+  const offsets = [0];
+  for (let i = 0; i < content.length; i++) {
+    if (content[i] === "\n") {
+      offsets.push(i + 1);
+    }
+  }
+  if (offsets[offsets.length - 1] !== content.length) {
+    offsets.push(content.length);
+  }
+  return offsets;
+}
+function resolveLineMeta(content, offsets, index) {
+  let low = 0;
+  let high = offsets.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const start = offsets[mid];
+    if (start === void 0) {
+      break;
+    }
+    const nextStart = offsets[mid + 1] ?? content.length;
+    if (index < start) {
+      high = mid - 1;
+      continue;
+    }
+    if (index >= nextStart) {
+      low = mid + 1;
+      continue;
+    }
+    const line = mid + 1;
+    const column = index - start + 1;
+    const lineEnd = content.indexOf("\n", start);
+    const lineText = content.slice(start, lineEnd === -1 ? content.length : lineEnd);
+    return { line, column, lineText };
+  }
+  const lastStart = offsets[offsets.length - 2] ?? 0;
+  return {
+    line: offsets.length - 1,
+    column: index - lastStart + 1,
+    lineText: content.slice(lastStart)
+  };
+}
+function toExtension(filename) {
+  const ext = path2.extname(filename).replace(/^\./, "");
+  return ext || "txt";
+}
+function toRelativeFile(cwd, filename) {
+  const relative = path2.relative(cwd, filename);
+  return relative === "" ? path2.basename(filename) : relative;
+}
+async function extractProjectCandidatesWithPositions(options) {
+  const cwd = options?.cwd ? path2.resolve(options.cwd) : process3.cwd();
+  const normalizedSources = normalizeSources(options?.sources, cwd);
+  const { Scanner } = await importOxide();
+  const scanner = new Scanner({
+    sources: normalizedSources
+  });
+  const files = scanner.files ?? [];
+  const entries = [];
+  const skipped = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = await fs3.readFile(file, "utf8");
+    } catch (error) {
+      skipped.push({
+        file,
+        reason: error instanceof Error ? error.message : "Unknown error"
+      });
+      continue;
+    }
+    const extension = toExtension(file);
+    const matches = scanner.getCandidatesWithPositions({
+      file,
+      content,
+      extension
+    });
+    if (!matches.length) {
+      continue;
+    }
+    const offsets = buildLineOffsets(content);
+    const relativeFile = toRelativeFile(cwd, file);
+    for (const match of matches) {
+      const info = resolveLineMeta(content, offsets, match.position);
+      entries.push({
+        rawCandidate: match.candidate,
+        file,
+        relativeFile,
+        extension,
+        start: match.position,
+        end: match.position + match.candidate.length,
+        length: match.candidate.length,
+        line: info.line,
+        column: info.column,
+        lineText: info.lineText
+      });
+    }
+  }
+  return {
+    entries,
+    filesScanned: files.length,
+    skippedFiles: skipped,
+    sources: normalizedSources
+  };
+}
+function groupTokensByFile(report, options) {
+  const key = options?.key ?? "relative";
+  const stripAbsolute = options?.stripAbsolutePaths ?? key !== "absolute";
+  return report.entries.reduce((acc, entry) => {
+    const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
+    if (!acc[bucketKey]) {
+      acc[bucketKey] = [];
+    }
+    const value = stripAbsolute ? {
+      ...entry,
+      file: entry.relativeFile
+    } : entry;
+    acc[bucketKey].push(value);
+    return acc;
+  }, {});
+}
+
+// src/options/normalize.ts
+import process4 from "process";
+import fs4 from "fs-extra";
+import path3 from "pathe";
+var hasWarnedDeprecatedOptions = false;
+var deprecatedOptionMapping = {
+  cwd: "projectRoot",
+  overwrite: "apply.overwrite",
+  tailwind: "tailwindcss",
+  features: "apply",
+  output: "extract"
+};
+function resolveRealpathSafe(value) {
+  const resolved = path3.resolve(value);
+  try {
+    return path3.normalize(fs4.realpathSync(resolved));
+  } catch {
+    return path3.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 = path3.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 ? path3.resolve(cache.dir) : path3.resolve(cwd, "node_modules/.cache", pkgName);
+    file = cache.file ?? file;
+    strategy = cache.strategy ?? strategy;
+    driver = normalizeCacheDriver(cache.driver);
+  }
+  const filename = path3.resolve(dir, file);
+  return {
+    enabled,
+    cwd,
+    dir,
+    file,
+    path: filename,
+    strategy,
+    driver
+  };
+}
+function normalizeOutputOptions(output) {
+  const enabled = output?.write ?? true;
+  const file = output?.file ?? ".tw-patch/tw-class-list.json";
+  const format = output?.format ?? "json";
+  const pretty = toPrettyValue(output?.pretty ?? true);
+  const removeUniversalSelector = output?.removeUniversalSelector ?? true;
+  return {
+    enabled,
+    file,
+    format,
+    pretty,
+    removeUniversalSelector
+  };
+}
+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 ? path3.resolve(v4.base) : void 0;
+  const base = configuredBase ?? fallbackBase;
+  const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => path3.resolve(entry)) : [];
+  const userSources = v4?.sources;
+  const hasUserDefinedSources = Boolean(userSources?.length);
+  const sources = hasUserDefinedSources ? userSources : [
+    {
+      base: fallbackBase,
+      pattern: "**/*",
+      negated: false
+    }
+  ];
+  return {
+    base,
+    ...configuredBase === void 0 ? {} : { configuredBase },
+    ...v4?.css === void 0 ? {} : { css: v4.css },
+    cssEntries,
+    sources,
+    hasUserDefinedSources
+  };
+}
+function normalizeTailwindOptions(tailwind, projectRoot) {
+  const packageName = tailwind?.packageName ?? "tailwindcss";
+  const versionHint = tailwind?.version;
+  const resolve = tailwind?.resolve;
+  const cwd = tailwind?.cwd ?? projectRoot;
+  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
+  };
+}
+function resolveOptionSlices(options) {
+  const projectRoot = options.projectRoot ?? options.cwd;
+  const overwrite = options.apply?.overwrite ?? options.overwrite;
+  const tailwind = options.tailwindcss ?? options.tailwind;
+  const exposeContext = options.apply?.exposeContext !== void 0 ? options.apply.exposeContext : options.features?.exposeContext;
+  const extendLengthUnits = options.apply?.extendLengthUnits !== void 0 ? options.apply.extendLengthUnits : options.features?.extendLengthUnits;
+  const write = options.extract?.write ?? options.output?.enabled;
+  const file = options.extract?.file ?? options.output?.file;
+  const format = options.extract?.format ?? options.output?.format;
+  const pretty = options.extract?.pretty ?? options.output?.pretty;
+  const removeUniversalSelector = options.extract?.removeUniversalSelector ?? options.output?.removeUniversalSelector;
+  const extract = {
+    ...write === void 0 ? {} : { write },
+    ...file === void 0 ? {} : { file },
+    ...format === void 0 ? {} : { format },
+    ...pretty === void 0 ? {} : { pretty },
+    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector }
+  };
+  return {
+    ...projectRoot === void 0 ? {} : { projectRoot },
+    ...overwrite === void 0 ? {} : { overwrite },
+    ...tailwind === void 0 ? {} : { tailwind },
+    ...Object.keys(extract).length === 0 ? {} : { extract },
+    ...exposeContext === void 0 ? {} : { exposeContext },
+    ...extendLengthUnits === void 0 ? {} : { extendLengthUnits }
+  };
+}
+function findUsedDeprecatedOptions(options) {
+  const result = [];
+  for (const key of Object.keys(deprecatedOptionMapping)) {
+    if (options[key] !== void 0) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function warnDeprecatedOptionsIfNeeded(options) {
+  if (hasWarnedDeprecatedOptions) {
+    return;
+  }
+  const used = findUsedDeprecatedOptions(options);
+  if (used.length === 0) {
+    return;
+  }
+  hasWarnedDeprecatedOptions = true;
+  const mapping = used.map((key) => `${key} -> ${deprecatedOptionMapping[key]}`).join(", ");
+  logger_default.warn(
+    `[deprecated] TailwindcssPatcher options (${used.join(", ")}) are deprecated and will be removed in the next major version. Please migrate to: ${mapping}.`
+  );
+}
+function normalizeOptions(options = {}) {
+  warnDeprecatedOptionsIfNeeded(options);
+  const resolved = resolveOptionSlices(options);
+  const projectRoot = resolveRealpathSafe(resolved.projectRoot ? path3.resolve(resolved.projectRoot) : process4.cwd());
+  const overwrite = resolved.overwrite ?? true;
+  const output = normalizeOutputOptions(resolved.extract);
+  const cache = normalizeCacheOptions(options.cache, projectRoot);
+  const tailwind = normalizeTailwindOptions(resolved.tailwind, projectRoot);
+  const exposeContext = normalizeExposeContextOptions(resolved.exposeContext);
+  const extendLengthUnits = normalizeExtendLengthUnitsOptions(resolved.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
+  };
+}
+
+// src/patching/status.ts
+import * as t4 from "@babel/types";
+import fs6 from "fs-extra";
+import path5 from "pathe";
+
+// src/babel/index.ts
+import _babelGenerate from "@babel/generator";
+import _babelTraverse from "@babel/traverse";
+import { parse, parseExpression } from "@babel/parser";
+function _interopDefaultCompat(e) {
+  return e && typeof e === "object" && "default" in e ? e.default : e;
+}
+var generate = _interopDefaultCompat(_babelGenerate);
+var traverse = _interopDefaultCompat(_babelTraverse);
+
+// src/patching/operations/export-context/postcss-v2.ts
+import * as t from "@babel/types";
+var 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 createExportsMember(property) {
+  if (IDENTIFIER_RE.test(property)) {
+    return t.memberExpression(t.identifier("exports"), t.identifier(property));
+  }
+  return t.memberExpression(t.identifier("exports"), t.stringLiteral(property), true);
+}
+function transformProcessTailwindFeaturesReturnContextV2(content) {
+  const ast = parse(content, {
+    sourceType: "unambiguous"
+  });
+  let hasPatched = false;
+  traverse(ast, {
+    FunctionDeclaration(path13) {
+      const node = path13.node;
+      if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
+        return;
+      }
+      const returnStatement3 = node.body.body[0];
+      if (!t.isFunctionExpression(returnStatement3.argument)) {
+        return;
+      }
+      const body = returnStatement3.argument.body.body;
+      const lastStatement = body[body.length - 1];
+      const alreadyReturnsContext = Boolean(
+        t.isReturnStatement(lastStatement) && t.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context"
+      );
+      hasPatched = alreadyReturnsContext;
+      if (!alreadyReturnsContext) {
+        body.push(t.returnStatement(t.identifier("context")));
+      }
+    }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+function transformPostcssPluginV2(content, options) {
+  const refIdentifier = t.identifier(toIdentifierName(options.refProperty));
+  const exportMember = createExportsMember(options.refProperty);
+  const valueMember = t.memberExpression(refIdentifier, t.identifier("value"));
+  const ast = parse(content);
+  let hasPatched = false;
+  traverse(ast, {
+    Program(path13) {
+      const program = path13.node;
+      const index = program.body.findIndex((statement) => {
+        return t.isFunctionDeclaration(statement) && statement.id?.name === "_default";
+      });
+      if (index === -1) {
+        return;
+      }
+      const previous = program.body[index - 1];
+      const beforePrevious = program.body[index - 2];
+      const alreadyHasVariable = Boolean(
+        previous && t.isVariableDeclaration(previous) && previous.declarations.length === 1 && t.isIdentifier(previous.declarations[0].id) && previous.declarations[0].id.name === refIdentifier.name
+      );
+      const alreadyAssignsExports = Boolean(
+        beforePrevious && t.isExpressionStatement(beforePrevious) && t.isAssignmentExpression(beforePrevious.expression) && t.isMemberExpression(beforePrevious.expression.left) && t.isIdentifier(beforePrevious.expression.right) && beforePrevious.expression.right.name === refIdentifier.name && generate(beforePrevious.expression.left).code === generate(exportMember).code
+      );
+      hasPatched = alreadyHasVariable && alreadyAssignsExports;
+      if (!alreadyHasVariable) {
+        program.body.splice(
+          index,
+          0,
+          t.variableDeclaration("var", [
+            t.variableDeclarator(
+              refIdentifier,
+              t.objectExpression([
+                t.objectProperty(t.identifier("value"), t.arrayExpression())
+              ])
+            )
+          ]),
+          t.expressionStatement(
+            t.assignmentExpression("=", exportMember, refIdentifier)
+          )
+        );
+      }
+    },
+    FunctionDeclaration(path13) {
+      if (hasPatched) {
+        return;
+      }
+      const fn = path13.node;
+      if (fn.id?.name !== "_default") {
+        return;
+      }
+      if (fn.body.body.length !== 1 || !t.isReturnStatement(fn.body.body[0])) {
+        return;
+      }
+      const returnStatement3 = fn.body.body[0];
+      if (!t.isCallExpression(returnStatement3.argument) || !t.isMemberExpression(returnStatement3.argument.callee) || !t.isArrayExpression(returnStatement3.argument.callee.object)) {
+        return;
+      }
+      const fnExpression = returnStatement3.argument.callee.object.elements[1];
+      if (!fnExpression || !t.isFunctionExpression(fnExpression)) {
+        return;
+      }
+      const block = fnExpression.body;
+      const statements = block.body;
+      if (t.isExpressionStatement(statements[0]) && t.isAssignmentExpression(statements[0].expression) && t.isNumericLiteral(statements[0].expression.right)) {
+        hasPatched = true;
+        return;
+      }
+      const lastStatement = statements[statements.length - 1];
+      if (lastStatement && t.isExpressionStatement(lastStatement)) {
+        statements[statements.length - 1] = t.expressionStatement(
+          t.callExpression(
+            t.memberExpression(valueMember, t.identifier("push")),
+            [lastStatement.expression]
+          )
+        );
+      }
+      const index = statements.findIndex((statement) => t.isIfStatement(statement));
+      if (index > -1) {
+        const ifStatement = statements[index];
+        if (t.isBlockStatement(ifStatement.consequent) && ifStatement.consequent.body[1] && t.isForOfStatement(ifStatement.consequent.body[1])) {
+          const forOf = ifStatement.consequent.body[1];
+          if (t.isBlockStatement(forOf.body) && forOf.body.body.length === 1) {
+            const nestedIf = forOf.body.body[0];
+            if (nestedIf && t.isIfStatement(nestedIf) && t.isBlockStatement(nestedIf.consequent) && nestedIf.consequent.body.length === 1 && t.isExpressionStatement(nestedIf.consequent.body[0])) {
+              nestedIf.consequent.body[0] = t.expressionStatement(
+                t.callExpression(
+                  t.memberExpression(valueMember, t.identifier("push")),
+                  [nestedIf.consequent.body[0].expression]
+                )
+              );
+            }
+          }
+        }
+      }
+      statements.unshift(
+        t.expressionStatement(
+          t.assignmentExpression(
+            "=",
+            t.memberExpression(valueMember, t.identifier("length")),
+            t.numericLiteral(0)
+          )
+        )
+      );
+    }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+
+// src/patching/operations/export-context/postcss-v3.ts
+import * as t2 from "@babel/types";
+var IDENTIFIER_RE2 = /^[A-Z_$][\w$]*$/i;
+function toIdentifierName2(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 = t2.memberExpression(t2.identifier("module"), t2.identifier("exports"));
+  if (IDENTIFIER_RE2.test(property)) {
+    return t2.memberExpression(object, t2.identifier(property));
+  }
+  return t2.memberExpression(object, t2.stringLiteral(property), true);
+}
+function transformProcessTailwindFeaturesReturnContext(content) {
+  const ast = parse(content);
+  let hasPatched = false;
+  traverse(ast, {
+    FunctionDeclaration(path13) {
+      const node = path13.node;
+      if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1) {
+        return;
+      }
+      const [returnStatement3] = node.body.body;
+      if (!t2.isReturnStatement(returnStatement3) || !t2.isFunctionExpression(returnStatement3.argument)) {
+        return;
+      }
+      const expression = returnStatement3.argument;
+      const body = expression.body.body;
+      const lastStatement = body[body.length - 1];
+      const alreadyReturnsContext = Boolean(
+        t2.isReturnStatement(lastStatement) && t2.isIdentifier(lastStatement.argument) && lastStatement.argument.name === "context"
+      );
+      hasPatched = alreadyReturnsContext;
+      if (!alreadyReturnsContext) {
+        body.push(t2.returnStatement(t2.identifier("context")));
+      }
+    }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+function transformPostcssPlugin(content, { refProperty }) {
+  const ast = parse(content);
+  const refIdentifier = t2.identifier(toIdentifierName2(refProperty));
+  const moduleExportsMember = createModuleExportsMember(refProperty);
+  const valueMember = t2.memberExpression(refIdentifier, t2.identifier("value"));
+  let hasPatched = false;
+  traverse(ast, {
+    Program(path13) {
+      const program = path13.node;
+      const index = program.body.findIndex((statement) => {
+        return t2.isExpressionStatement(statement) && t2.isAssignmentExpression(statement.expression) && t2.isMemberExpression(statement.expression.left) && t2.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 && t2.isVariableDeclaration(previousStatement) && previousStatement.declarations.length === 1 && t2.isIdentifier(previousStatement.declarations[0].id) && previousStatement.declarations[0].id.name === refIdentifier.name
+      );
+      const alreadyAssignsModuleExports = Boolean(
+        t2.isExpressionStatement(lastStatement) && t2.isAssignmentExpression(lastStatement.expression) && t2.isMemberExpression(lastStatement.expression.left) && t2.isIdentifier(lastStatement.expression.right) && lastStatement.expression.right.name === refIdentifier.name && generate(lastStatement.expression.left).code === generate(moduleExportsMember).code
+      );
+      hasPatched = alreadyHasVariable && alreadyAssignsModuleExports;
+      if (!alreadyHasVariable) {
+        program.body.splice(
+          index,
+          0,
+          t2.variableDeclaration("const", [
+            t2.variableDeclarator(
+              refIdentifier,
+              t2.objectExpression([
+                t2.objectProperty(t2.identifier("value"), t2.arrayExpression())
+              ])
+            )
+          ])
+        );
+      }
+      if (!alreadyAssignsModuleExports) {
+        program.body.push(
+          t2.expressionStatement(
+            t2.assignmentExpression("=", moduleExportsMember, refIdentifier)
+          )
+        );
+      }
+    },
+    FunctionExpression(path13) {
+      if (hasPatched) {
+        return;
+      }
+      const fn = path13.node;
+      if (fn.id?.name !== "tailwindcss" || fn.body.body.length !== 1) {
+        return;
+      }
+      const [returnStatement3] = fn.body.body;
+      if (!returnStatement3 || !t2.isReturnStatement(returnStatement3) || !t2.isObjectExpression(returnStatement3.argument)) {
+        return;
+      }
+      const properties = returnStatement3.argument.properties;
+      if (properties.length !== 2) {
+        return;
+      }
+      const pluginsProperty = properties.find(
+        (prop) => t2.isObjectProperty(prop) && t2.isIdentifier(prop.key) && prop.key.name === "plugins"
+      );
+      if (!pluginsProperty || !t2.isObjectProperty(pluginsProperty) || !t2.isCallExpression(pluginsProperty.value) || !t2.isMemberExpression(pluginsProperty.value.callee) || !t2.isArrayExpression(pluginsProperty.value.callee.object)) {
+        return;
+      }
+      const pluginsArray = pluginsProperty.value.callee.object.elements;
+      const targetPlugin = pluginsArray[1];
+      if (!targetPlugin || !t2.isFunctionExpression(targetPlugin)) {
+        return;
+      }
+      const block = targetPlugin.body;
+      const statements = block.body;
+      const last = statements[statements.length - 1];
+      if (last && t2.isExpressionStatement(last)) {
+        statements[statements.length - 1] = t2.expressionStatement(
+          t2.callExpression(
+            t2.memberExpression(valueMember, t2.identifier("push")),
+            [last.expression]
+          )
+        );
+      }
+      const index = statements.findIndex((s) => t2.isIfStatement(s));
+      if (index > -1) {
+        const ifStatement = statements[index];
+        if (t2.isBlockStatement(ifStatement.consequent)) {
+          const [, second] = ifStatement.consequent.body;
+          if (second && t2.isForOfStatement(second) && t2.isBlockStatement(second.body)) {
+            const bodyStatement = second.body.body[0];
+            if (bodyStatement && t2.isIfStatement(bodyStatement) && t2.isBlockStatement(bodyStatement.consequent) && bodyStatement.consequent.body.length === 1 && t2.isExpressionStatement(bodyStatement.consequent.body[0])) {
+              bodyStatement.consequent.body[0] = t2.expressionStatement(
+                t2.callExpression(
+                  t2.memberExpression(valueMember, t2.identifier("push")),
+                  [bodyStatement.consequent.body[0].expression]
+                )
+              );
+            }
+          }
+        }
+      }
+      statements.unshift(
+        t2.expressionStatement(
+          t2.assignmentExpression(
+            "=",
+            t2.memberExpression(valueMember, t2.identifier("length")),
+            t2.numericLiteral(0)
+          )
+        )
+      );
+    }
+  });
+  return {
+    code: hasPatched ? content : generate(ast).code,
+    hasPatched
+  };
+}
+
+// src/patching/operations/extend-length-units.ts
+import * as t3 from "@babel/types";
+import fs5 from "fs-extra";
+import path4 from "pathe";
+
+// src/utils.ts
+function isObject(val) {
+  return val !== null && typeof val === "object" && Array.isArray(val) === false;
+}
+function spliceChangesIntoString(str, changes) {
+  if (!changes[0]) {
+    return str;
+  }
+  changes.sort((a, b) => {
+    return a.end - b.end || a.start - b.start;
+  });
+  let result = "";
+  let previous = changes[0];
+  result += str.slice(0, previous.start);
+  result += previous.replacement;
+  for (let i = 1; i < changes.length; ++i) {
+    const change = changes[i];
+    result += str.slice(previous.end, change.start);
+    result += change.replacement;
+    previous = change;
+  }
+  result += str.slice(previous.end);
+  return result;
+}
+
+// src/patching/operations/extend-length-units.ts
+function updateLengthUnitsArray(content, options) {
+  const { variableName = "lengthUnits", units } = options;
+  const ast = parse(content);
+  let arrayRef;
+  let changed = false;
+  traverse(ast, {
+    Identifier(path13) {
+      if (path13.node.name === variableName && t3.isVariableDeclarator(path13.parent) && t3.isArrayExpression(path13.parent.init)) {
+        arrayRef = path13.parent.init;
+        const existing = new Set(
+          path13.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+        );
+        for (const unit of units) {
+          if (!existing.has(unit)) {
+            path13.parent.init.elements = path13.parent.init.elements.map((element) => {
+              if (t3.isStringLiteral(element)) {
+                return t3.stringLiteral(element.value);
+              }
+              return element;
+            });
+            path13.parent.init.elements.push(t3.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 = path4.resolve(rootDir, opts.lengthUnitsFilePath);
+  const exists = fs5.existsSync(dataTypesFilePath);
+  if (!exists) {
+    return { changed: false, code: void 0 };
+  }
+  const content = fs5.readFileSync(dataTypesFilePath, "utf8");
+  const { arrayRef, changed } = updateLengthUnitsArray(content, opts);
+  if (!arrayRef || !changed) {
+    return { changed: false, code: void 0 };
+  }
+  const { code } = generate(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 ? path4.resolve(opts.destPath) : dataTypesFilePath;
+      fs5.writeFileSync(target, nextCode, "utf8");
+      logger_default.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 = path4.resolve(rootDir, "dist");
+  if (!fs5.existsSync(distDir)) {
+    return { files: [], changed: false };
+  }
+  const entries = fs5.readdirSync(distDir);
+  const chunkNames = entries.filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs"));
+  const pattern = /\[\s*["']cm["'],\s*["']mm["'],[\w,"']+\]/;
+  const candidates = chunkNames.map((chunkName) => {
+    const file = path4.join(distDir, chunkName);
+    const code = fs5.readFileSync(file, "utf8");
+    const match = pattern.exec(code);
+    if (!match) {
+      return null;
+    }
+    return {
+      file,
+      code,
+      match,
+      hasPatched: false
+    };
+  }).filter((candidate) => candidate !== null);
+  for (const item of candidates) {
+    const { code, file, match } = item;
+    const ast = parse(match[0], { sourceType: "unambiguous" });
+    traverse(ast, {
+      ArrayExpression(path13) {
+        for (const unit of opts.units) {
+          if (path13.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
+            item.hasPatched = true;
+            return;
+          }
+          path13.node.elements.push(t3.stringLiteral(unit));
+        }
+      }
+    });
+    if (item.hasPatched) {
+      continue;
+    }
+    const { code: replacement } = generate(ast, { minified: true });
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    item.code = spliceChangesIntoString(code, [
+      {
+        start,
+        end,
+        replacement: replacement.endsWith(";") ? replacement.slice(0, -1) : replacement
+      }
+    ]);
+    if (opts.overwrite) {
+      fs5.writeFileSync(file, item.code, "utf8");
+    }
+  }
+  if (candidates.some((file) => !file.hasPatched)) {
+    logger_default.success("Patched Tailwind CSS length unit list (v4).");
+  }
+  return {
+    changed: candidates.some((file) => !file.hasPatched),
+    files: candidates
+  };
+}
+
+// src/patching/status.ts
+function inspectLengthUnitsArray(content, variableName, units) {
+  const ast = parse(content);
+  let found = false;
+  let missingUnits = [];
+  traverse(ast, {
+    Identifier(path13) {
+      if (path13.node.name === variableName && t4.isVariableDeclarator(path13.parent) && t4.isArrayExpression(path13.parent.init)) {
+        found = true;
+        const existing = new Set(
+          path13.parent.init.elements.map((element) => t4.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+        );
+        missingUnits = units.filter((unit) => !existing.has(unit));
+        path13.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 = path5.resolve(packageInfo.rootPath, relative);
+    if (!fs6.existsSync(filePath)) {
+      checks.push({ relative, exists: false, patched: false });
+      return;
+    }
+    const content = fs6.readFileSync(filePath, "utf8");
+    const { hasPatched } = transform(content);
+    checks.push({
+      relative,
+      exists: true,
+      patched: hasPatched
+    });
+  }
+  if (majorVersion === 3) {
+    inspectFile("lib/processTailwindFeatures.js", transformProcessTailwindFeaturesReturnContext);
+    const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
+    const pluginRelative = pluginCandidates.find((candidate) => fs6.existsSync(path5.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 = path5.resolve(rootDir, lengthUnitsFilePath);
+  const files = fs6.existsSync(target) ? [path5.relative(rootDir, target)] : [];
+  if (!fs6.existsSync(target)) {
+    return {
+      name: "extendLengthUnits",
+      status: "not-applied",
+      reason: `missing ${lengthUnitsFilePath}`,
+      files
+    };
+  }
+  const content = fs6.readFileSync(target, "utf8");
+  const { found, missingUnits } = inspectLengthUnitsArray(content, 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 = path5.resolve(rootDir, "dist");
+  if (!fs6.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) => path5.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) => path5.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)
+    ]
+  };
+}
+
+// src/runtime/class-collector.ts
+import process5 from "process";
+import fs7 from "fs-extra";
+import path6 from "pathe";
+function collectClassesFromContexts(contexts, filter) {
+  const set = /* @__PURE__ */ new Set();
+  for (const context of contexts) {
+    if (!isObject(context) || !context.classCache) {
+      continue;
+    }
+    for (const key of context.classCache.keys()) {
+      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 void 0;
+    }
+    return path6.isAbsolute(value) ? value : path6.resolve(options.projectRoot, value);
+  };
+  const resolvedConfiguredBase = toAbsolute(v4Options.configuredBase);
+  const resolvedDefaultBase = toAbsolute(v4Options.base) ?? process5.cwd();
+  const resolveSources = (base) => {
+    if (!v4Options.sources?.length) {
+      return void 0;
+    }
+    return v4Options.sources.map((source) => ({
+      base: source.base ?? base,
+      pattern: source.pattern,
+      negated: source.negated
+    }));
+  };
+  if (v4Options.cssEntries.length > 0) {
+    for (const entry of v4Options.cssEntries) {
+      const filePath = path6.isAbsolute(entry) ? entry : path6.resolve(options.projectRoot, entry);
+      if (!await fs7.pathExists(filePath)) {
+        continue;
+      }
+      const css = await fs7.readFile(filePath, "utf8");
+      const entryDir = path6.dirname(filePath);
+      const designSystemBases = resolvedConfiguredBase && resolvedConfiguredBase !== entryDir ? [entryDir, resolvedConfiguredBase] : [entryDir];
+      const sourcesBase = resolvedConfiguredBase ?? entryDir;
+      const sources = resolveSources(sourcesBase);
+      const firstBase = designSystemBases[0] ?? entryDir;
+      const extractOptions = {
+        cwd: options.projectRoot,
+        base: firstBase,
+        baseFallbacks: designSystemBases.slice(1),
+        css,
+        ...sources === void 0 ? {} : { sources }
+      };
+      const candidates = await extractValidCandidates(extractOptions);
+      for (const candidate of candidates) {
+        if (options.filter(candidate)) {
+          set.add(candidate);
+        }
+      }
+    }
+  } else {
+    const baseForCss = resolvedConfiguredBase ?? resolvedDefaultBase;
+    const sources = resolveSources(baseForCss);
+    const extractOptions = {
+      cwd: options.projectRoot,
+      base: baseForCss,
+      ...v4Options.css === void 0 ? {} : { css: v4Options.css },
+      ...sources === void 0 ? {} : { sources }
+    };
+    const candidates = await extractValidCandidates(extractOptions);
+    for (const candidate of candidates) {
+      if (options.filter(candidate)) {
+        set.add(candidate);
+      }
+    }
+  }
+  return set;
+}
+
+// src/runtime/context-registry.ts
+import { createRequire } from "module";
+import fs8 from "fs-extra";
+import path7 from "pathe";
+var require2 = createRequire(import.meta.url);
+function resolveRuntimeEntry(packageInfo, majorVersion) {
+  const root = packageInfo.rootPath;
+  if (majorVersion === 2) {
+    const jitIndex = path7.join(root, "lib/jit/index.js");
+    if (fs8.existsSync(jitIndex)) {
+      return jitIndex;
+    }
+  } else if (majorVersion === 3) {
+    const plugin = path7.join(root, "lib/plugin.js");
+    const index = path7.join(root, "lib/index.js");
+    if (fs8.existsSync(plugin)) {
+      return plugin;
+    }
+    if (fs8.existsSync(index)) {
+      return index;
+    }
+  }
+  return void 0;
+}
+function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
+  if (majorVersion === 4) {
+    return [];
+  }
+  const entry = resolveRuntimeEntry(packageInfo, majorVersion);
+  if (!entry) {
+    return [];
+  }
+  const moduleExports = require2(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 [];
+}
+
+// src/runtime/process-tailwindcss.ts
+import { createRequire as createRequire2 } from "module";
+import path8 from "pathe";
+import postcss from "postcss";
+import { loadConfig } from "tailwindcss-config";
+var require3 = createRequire2(import.meta.url);
+async function resolveConfigPath(options) {
+  if (options.config && path8.isAbsolute(options.config)) {
+    return options.config;
+  }
+  const result = await loadConfig({ cwd: options.cwd });
+  if (!result) {
+    throw new Error(`Unable to locate Tailwind CSS config from ${options.cwd}`);
+  }
+  return result.filepath;
+}
+async function runTailwindBuild(options) {
+  const configPath = await resolveConfigPath(options);
+  const pluginName = options.postcssPlugin ?? (options.majorVersion === 4 ? "@tailwindcss/postcss" : "tailwindcss");
+  if (options.majorVersion === 4) {
+    return postcss([
+      require3(pluginName)({
+        config: configPath
+      })
+    ]).process("@import 'tailwindcss';", {
+      from: void 0
+    });
+  }
+  return postcss([
+    require3(pluginName)({
+      config: configPath
+    })
+  ]).process("@tailwind base;@tailwind components;@tailwind utilities;", {
+    from: void 0
+  });
+}
+
+// src/api/tailwindcss-patcher.ts
+import process6 from "process";
+import fs10 from "fs-extra";
+import { getPackageInfoSync } from "local-pkg";
+import path10 from "pathe";
+import { coerce } from "semver";
+
+// src/options/legacy.ts
+function normalizeLegacyFeatures(patch) {
+  const apply = patch?.applyPatches;
+  const extend = apply?.extendLengthUnits;
+  let extendOption = false;
+  if (extend && typeof extend === "object") {
+    extendOption = {
+      ...extend,
+      enabled: true
+    };
+  } else if (extend === true) {
+    extendOption = {
+      enabled: true,
+      units: ["rpx"],
+      ...patch?.overwrite === void 0 ? {} : { overwrite: patch.overwrite }
+    };
+  }
+  return {
+    exposeContext: apply?.exportContext ?? true,
+    extendLengthUnits: extendOption
+  };
+}
+function fromLegacyOptions(options) {
+  if (!options) {
+    return {};
+  }
+  const patch = options.patch;
+  const features = normalizeLegacyFeatures(patch);
+  const output = patch?.output;
+  const tailwindConfig = patch?.tailwindcss;
+  const tailwindVersion = tailwindConfig?.version;
+  const tailwindV2 = tailwindConfig?.v2;
+  const tailwindV3 = tailwindConfig?.v3;
+  const tailwindV4 = tailwindConfig?.v4;
+  const tailwindConfigPath = tailwindV3?.config ?? tailwindV2?.config;
+  const tailwindCwd = tailwindV3?.cwd ?? tailwindV2?.cwd ?? patch?.cwd;
+  const normalizedExtract = output ? {
+    ...output.filename === void 0 ? {} : { file: output.filename },
+    pretty: output.loose ? 2 : false,
+    ...output.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: output.removeUniversalSelector }
+  } : void 0;
+  const normalizedTailwindcss = {
+    ...patch?.packageName === void 0 ? {} : { packageName: patch.packageName },
+    ...tailwindVersion === void 0 ? {} : { version: tailwindVersion },
+    ...patch?.resolve === void 0 ? {} : { resolve: patch.resolve },
+    ...tailwindConfigPath === void 0 ? {} : { config: tailwindConfigPath },
+    ...tailwindCwd === void 0 ? {} : { cwd: tailwindCwd },
+    ...tailwindV2 === void 0 ? {} : { v2: tailwindV2 },
+    ...tailwindV3 === void 0 ? {} : { v3: tailwindV3 },
+    ...tailwindV4 === void 0 ? {} : { v4: tailwindV4 }
+  };
+  const normalizedCache = typeof options.cache === "boolean" ? options.cache : options.cache ? {
+    ...options.cache,
+    enabled: options.cache.enabled ?? true
+  } : void 0;
+  const normalizedApply = {
+    ...patch?.overwrite === void 0 ? {} : { overwrite: patch.overwrite },
+    exposeContext: features.exposeContext,
+    extendLengthUnits: features.extendLengthUnits
+  };
+  return {
+    ...patch?.cwd === void 0 ? {} : { projectRoot: patch.cwd },
+    ...patch?.filter === void 0 ? {} : { filter: patch.filter },
+    ...normalizedCache === void 0 ? {} : { cache: normalizedCache },
+    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
+    ...Object.keys(normalizedTailwindcss).length === 0 ? {} : { tailwindcss: normalizedTailwindcss },
+    apply: normalizedApply
+  };
+}
+function fromUnifiedConfig(registry) {
+  if (!registry) {
+    return {};
+  }
+  const tailwind = registry.tailwindcss ?? registry.tailwind;
+  const modernExtract = registry.extract;
+  const legacyOutput = registry.output;
+  const pretty = (() => {
+    const value = modernExtract?.pretty ?? legacyOutput?.pretty;
+    if (value === void 0) {
+      return void 0;
+    }
+    if (typeof value === "boolean") {
+      return value ? 2 : false;
+    }
+    return value;
+  })();
+  const removeUniversalSelector = modernExtract?.removeUniversalSelector ?? legacyOutput?.stripUniversalSelector;
+  const outputFile = modernExtract?.file ?? legacyOutput?.file;
+  const normalizedExtract = modernExtract || legacyOutput ? {
+    ...modernExtract?.write === void 0 ? {} : { write: modernExtract.write },
+    ...outputFile === void 0 ? {} : { file: outputFile },
+    ...pretty === void 0 ? {} : { pretty },
+    ...removeUniversalSelector === void 0 ? {} : { removeUniversalSelector },
+    ...modernExtract?.format === void 0 ? {} : { format: modernExtract.format }
+  } : void 0;
+  const normalizedTailwindcss = tailwind ? {
+    ...tailwind.version === void 0 ? {} : { version: tailwind.version },
+    ...tailwind.packageName === void 0 ? tailwind.package === void 0 ? {} : { packageName: tailwind.package } : { packageName: tailwind.packageName },
+    ...tailwind.resolve === void 0 ? {} : { resolve: tailwind.resolve },
+    ...tailwind.config === void 0 ? {} : { config: tailwind.config },
+    ...tailwind.cwd === void 0 ? {} : { cwd: tailwind.cwd },
+    ...tailwind.v2 === void 0 ? tailwind.legacy === void 0 ? {} : { v2: tailwind.legacy } : { v2: tailwind.v2 },
+    ...tailwind.v3 === void 0 ? tailwind.classic === void 0 ? {} : { v3: tailwind.classic } : { v3: tailwind.v3 },
+    ...tailwind.v4 === void 0 ? tailwind.next === void 0 ? {} : { v4: tailwind.next } : { v4: tailwind.v4 }
+  } : void 0;
+  const normalizedApply = 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 },
+    ...normalizedApply === void 0 ? {} : { apply: normalizedApply },
+    ...registry.cache === void 0 ? {} : { cache: registry.cache },
+    ...registry.filter === void 0 ? {} : { filter: registry.filter },
+    ...normalizedExtract === void 0 ? {} : { extract: normalizedExtract },
+    ...normalizedTailwindcss === void 0 ? {} : { tailwindcss: normalizedTailwindcss }
+  };
+}
+
+// src/patching/operations/export-context/index.ts
+import fs9 from "fs-extra";
+import path9 from "pathe";
+function writeFileIfRequired(filePath, code, overwrite, successMessage) {
+  if (!overwrite) {
+    return;
+  }
+  fs9.writeFileSync(filePath, code, {
+    encoding: "utf8"
+  });
+  logger_default.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 = path9.resolve(rootDir, processFileRelative);
+    if (fs9.existsSync(processFilePath)) {
+      const content = fs9.readFileSync(processFilePath, "utf8");
+      const { code, hasPatched } = transformProcessTailwindFeaturesReturnContext(content);
+      result.files[processFileRelative] = code;
+      if (!hasPatched) {
+        writeFileIfRequired(
+          processFilePath,
+          code,
+          overwrite,
+          "Patched Tailwind CSS processTailwindFeatures to expose runtime context."
+        );
+        result.applied = true;
+      }
+    }
+    const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
+    const pluginRelative = pluginCandidates.find((candidate) => fs9.existsSync(path9.resolve(rootDir, candidate)));
+    if (pluginRelative) {
+      const pluginPath = path9.resolve(rootDir, pluginRelative);
+      const content = fs9.readFileSync(pluginPath, "utf8");
+      const { code, hasPatched } = transformPostcssPlugin(content, { 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 = path9.resolve(rootDir, processFileRelative);
+    if (fs9.existsSync(processFilePath)) {
+      const content = fs9.readFileSync(processFilePath, "utf8");
+      const { code, hasPatched } = transformProcessTailwindFeaturesReturnContextV2(content);
+      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 = path9.resolve(rootDir, pluginRelative);
+    if (fs9.existsSync(pluginPath)) {
+      const content = fs9.readFileSync(pluginPath, "utf8");
+      const { code, hasPatched } = transformPostcssPluginV2(content, { 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;
+}
+
+// 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;
+}
+
+// src/api/tailwindcss-patcher.ts
+function resolveMajorVersion(version, hint) {
+  if (hint && [2, 3, 4].includes(hint)) {
+    return hint;
+  }
+  if (version) {
+    const coerced = coerce(version);
+    if (coerced) {
+      const major = coerced.major;
+      if (major === 2 || major === 3 || major === 4) {
+        return major;
+      }
+      if (major >= 4) {
+        return 4;
+      }
+    }
+  }
+  return 3;
+}
+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 TailwindcssPatcher = class {
+  options;
+  packageInfo;
+  majorVersion;
+  cacheContext;
+  cacheStore;
+  constructor(options = {}) {
+    const resolvedOptions = options && typeof options === "object" && "patch" in options ? fromLegacyOptions(options) : options;
+    this.options = normalizeOptions(resolvedOptions);
+    const packageInfo = getPackageInfoSync(
+      this.options.tailwind.packageName,
+      this.options.tailwind.resolve
+    );
+    if (!packageInfo) {
+      throw new Error(`Unable to locate Tailwind CSS package "${this.options.tailwind.packageName}".`);
+    }
+    this.packageInfo = packageInfo;
+    this.majorVersion = resolveMajorVersion(
+      this.packageInfo.version,
+      this.options.tailwind.versionHint
+    );
+    this.cacheContext = createCacheContextDescriptor(
+      this.options,
+      this.packageInfo,
+      this.majorVersion
+    );
+    this.cacheStore = new CacheStore(this.options.cache, this.cacheContext);
+  }
+  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
+    );
+  }
+  async runTailwindBuildIfNeeded() {
+    if (this.majorVersion === 2 || this.majorVersion === 3) {
+      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 }
+      };
+      await runTailwindBuild(buildOptions);
+    }
+  }
+  async collectClassSet() {
+    if (this.majorVersion === 4) {
+      return collectClassesFromTailwindV4(this.options);
+    }
+    const contexts = this.getContexts();
+    return collectClassesFromContexts(contexts, this.options.filter);
+  }
+  debugCacheRead(meta) {
+    if (meta.hit) {
+      logger_default.debug(
+        `[cache] hit fingerprint=${meta.fingerprint?.slice(0, 12) ?? "n/a"} schema=${meta.schemaVersion ?? "legacy"} ${meta.details.join("; ")}`
+      );
+      return;
+    }
+    logger_default.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 = await this.cacheStore.write(set);
+      if (writeTarget) {
+        logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
+      }
+    } else {
+      if (set.size > 0) {
+        const writeTarget = await this.cacheStore.write(set);
+        if (writeTarget) {
+          logger_default.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.cacheStore.writeSync(set);
+      if (writeTarget) {
+        logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
+      }
+    } else {
+      if (set.size > 0) {
+        const writeTarget = this.cacheStore.writeSync(set);
+        if (writeTarget) {
+          logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
+        }
+      } else {
+        return existing;
+      }
+    }
+    return set;
+  }
+  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 void 0;
+    }
+    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 = path10.resolve(this.options.output.file);
+    await fs10.ensureDir(path10.dirname(target));
+    if (this.options.output.format === "json") {
+      const spaces = typeof this.options.output.pretty === "number" ? this.options.output.pretty : void 0;
+      await fs10.writeJSON(target, classList, { spaces });
+    } else {
+      await fs10.writeFile(target, `${classList.join("\n")}
+`, "utf8");
+    }
+    logger_default.success(`Tailwind CSS class list saved to ${target.replace(process6.cwd(), ".")}`);
+    return {
+      ...result,
+      filename: target
+    };
+  }
+  async clearCache(options) {
+    const result = await this.cacheStore.clear(options);
+    logger_default.debug(
+      `[cache] clear scope=${result.scope} contexts=${result.contextsRemoved} entries=${result.entriesRemoved} files=${result.filesRemoved}`
+    );
+    return result;
+  }
+  // Backwards compatibility helper used by tests and API consumers.
+  extractValidCandidates = extractValidCandidates;
+  async collectContentTokens(options) {
+    return extractProjectCandidatesWithPositions({
+      cwd: options?.cwd ?? this.options.projectRoot,
+      sources: options?.sources ?? this.options.tailwind.v4?.sources ?? []
+    });
+  }
+  async collectContentTokensByFile(options) {
+    const collectContentOptions = {
+      ...options?.cwd === void 0 ? {} : { cwd: options.cwd },
+      ...options?.sources === void 0 ? {} : { sources: options.sources }
+    };
+    const report = await this.collectContentTokens(collectContentOptions);
+    const groupOptions = {
+      ...options?.key === void 0 ? {} : { key: options.key },
+      ...options?.stripAbsolutePaths === void 0 ? {} : { stripAbsolutePaths: options.stripAbsolutePaths }
+    };
+    return groupTokensByFile(report, groupOptions);
+  }
+};
+
+// src/cli/migrate-config.ts
+import { parse as parse2 } from "@babel/parser";
+import generate2 from "@babel/generator";
+import * as t5 from "@babel/types";
+import fs11 from "fs-extra";
+import path11 from "pathe";
+var 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"
+];
+var DEFAULT_CONFIG_FILENAME_SET = new Set(DEFAULT_CONFIG_FILENAMES);
+var DEFAULT_WORKSPACE_IGNORED_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".idea",
+  ".turbo",
+  ".vscode",
+  ".yarn",
+  "coverage",
+  "dist",
+  "node_modules",
+  "tmp"
+]);
+var DEFAULT_WORKSPACE_MAX_DEPTH = 6;
+var MIGRATION_REPORT_KIND = "tw-patch-migrate-report";
+var MIGRATION_REPORT_SCHEMA_VERSION = 1;
+var ROOT_LEGACY_KEYS = ["cwd", "overwrite", "tailwind", "features", "output", "applyPatches"];
+function getPropertyKeyName(property) {
+  if (!property.computed && t5.isIdentifier(property.key)) {
+    return property.key.name;
+  }
+  if (t5.isStringLiteral(property.key)) {
+    return property.key.value;
+  }
+  return void 0;
+}
+function findObjectProperty(objectExpression4, name) {
+  for (const property of objectExpression4.properties) {
+    if (!t5.isObjectProperty(property)) {
+      continue;
+    }
+    if (getPropertyKeyName(property) === name) {
+      return property;
+    }
+  }
+  return void 0;
+}
+function findObjectExpressionProperty(objectExpression4, name) {
+  const property = findObjectProperty(objectExpression4, name);
+  if (!property) {
+    return void 0;
+  }
+  if (t5.isObjectExpression(property.value)) {
+    return property.value;
+  }
+  return void 0;
+}
+function removeObjectProperty(objectExpression4, property) {
+  const index = objectExpression4.properties.indexOf(property);
+  if (index >= 0) {
+    objectExpression4.properties.splice(index, 1);
+  }
+}
+function hasObjectProperty(objectExpression4, name) {
+  return findObjectProperty(objectExpression4, name) !== void 0;
+}
+function keyAsIdentifier(name) {
+  return t5.identifier(name);
+}
+function mergeObjectProperties(target, source) {
+  let changed = false;
+  for (const sourceProperty of source.properties) {
+    if (t5.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(objectExpression4, from, to, changes, scope) {
+  const source = findObjectProperty(objectExpression4, from);
+  if (!source) {
+    return false;
+  }
+  const target = findObjectProperty(objectExpression4, to);
+  if (!target) {
+    source.key = keyAsIdentifier(to);
+    source.computed = false;
+    source.shorthand = false;
+    changes.add(`${scope}.${from} -> ${scope}.${to}`);
+    return true;
+  }
+  if (t5.isObjectExpression(source.value) && t5.isObjectExpression(target.value)) {
+    const merged = mergeObjectProperties(target.value, source.value);
+    if (merged) {
+      changes.add(`${scope}.${from} merged into ${scope}.${to}`);
+    }
+  }
+  removeObjectProperty(objectExpression4, 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(objectExpression4, name, changes, scope) {
+  const existing = findObjectProperty(objectExpression4, name);
+  if (existing) {
+    return t5.isObjectExpression(existing.value) ? existing.value : void 0;
+  }
+  const value = t5.objectExpression([]);
+  objectExpression4.properties.push(t5.objectProperty(keyAsIdentifier(name), value));
+  changes.add(`${scope}.${name} created`);
+  return value;
+}
+function moveOverwriteToApply(objectExpression4, changes, scope) {
+  const overwrite = findObjectProperty(objectExpression4, "overwrite");
+  if (!overwrite) {
+    return false;
+  }
+  const apply = ensureObjectExpressionProperty(objectExpression4, "apply", changes, scope);
+  if (!apply) {
+    return false;
+  }
+  const hasApplyOverwrite = hasObjectProperty(apply, "overwrite");
+  if (!hasApplyOverwrite) {
+    apply.properties.push(
+      t5.objectProperty(keyAsIdentifier("overwrite"), overwrite.value)
+    );
+    changes.add(`${scope}.overwrite -> ${scope}.apply.overwrite`);
+  }
+  removeObjectProperty(objectExpression4, overwrite);
+  return true;
+}
+function hasAnyRootLegacyKeys(objectExpression4) {
+  return ROOT_LEGACY_KEYS.some((key) => hasObjectProperty(objectExpression4, key));
+}
+function migrateOptionObject(objectExpression4, scope, changes) {
+  let changed = false;
+  changed = moveProperty(objectExpression4, "cwd", "projectRoot", changes, scope) || changed;
+  changed = moveProperty(objectExpression4, "tailwind", "tailwindcss", changes, scope) || changed;
+  changed = moveProperty(objectExpression4, "features", "apply", changes, scope) || changed;
+  changed = moveProperty(objectExpression4, "applyPatches", "apply", changes, scope) || changed;
+  changed = moveProperty(objectExpression4, "output", "extract", changes, scope) || changed;
+  changed = moveOverwriteToApply(objectExpression4, changes, scope) || changed;
+  const extract = findObjectExpressionProperty(objectExpression4, "extract");
+  if (extract) {
+    changed = migrateExtractOptions(extract, changes, scope) || changed;
+  }
+  const tailwindcss = findObjectExpressionProperty(objectExpression4, "tailwindcss");
+  if (tailwindcss) {
+    changed = migrateTailwindOptions(tailwindcss, changes, scope) || changed;
+  }
+  const apply = findObjectExpressionProperty(objectExpression4, "apply");
+  if (apply) {
+    changed = migrateApplyOptions(apply, changes, scope) || changed;
+  }
+  return changed;
+}
+function unwrapExpression(node) {
+  let current = node;
+  while (t5.isTSAsExpression(current) || t5.isTSSatisfiesExpression(current) || t5.isTSTypeAssertion(current) || t5.isParenthesizedExpression(current)) {
+    current = current.expression;
+  }
+  return current;
+}
+function resolveObjectExpressionFromExpression(expression) {
+  const unwrapped = unwrapExpression(expression);
+  if (t5.isObjectExpression(unwrapped)) {
+    return unwrapped;
+  }
+  if (t5.isCallExpression(unwrapped)) {
+    const [firstArg] = unwrapped.arguments;
+    if (!firstArg || !t5.isExpression(firstArg)) {
+      return void 0;
+    }
+    const firstArgUnwrapped = unwrapExpression(firstArg);
+    if (t5.isObjectExpression(firstArgUnwrapped)) {
+      return firstArgUnwrapped;
+    }
+  }
+  return void 0;
+}
+function resolveObjectExpressionFromProgram(program, name) {
+  for (const statement of program.body) {
+    if (!t5.isVariableDeclaration(statement)) {
+      continue;
+    }
+    for (const declaration of statement.declarations) {
+      if (!t5.isIdentifier(declaration.id) || declaration.id.name !== name || !declaration.init) {
+        continue;
+      }
+      const objectExpression4 = resolveObjectExpressionFromExpression(declaration.init);
+      if (objectExpression4) {
+        return objectExpression4;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveRootConfigObjectExpression(program) {
+  for (const statement of program.body) {
+    if (!t5.isExportDefaultDeclaration(statement)) {
+      continue;
+    }
+    const declaration = statement.declaration;
+    if (t5.isIdentifier(declaration)) {
+      return resolveObjectExpressionFromProgram(program, declaration.name);
+    }
+    const objectExpression4 = resolveObjectExpressionFromExpression(declaration);
+    if (objectExpression4) {
+      return objectExpression4;
+    }
+  }
+  return void 0;
+}
+function migrateConfigSource(source) {
+  const ast = parse2(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 = generate2(ast, {
+    comments: true
+  }).code;
+  const code = source.endsWith("\n") ? `${generated}
+` : generated;
+  return {
+    changed: true,
+    code,
+    changes: [...changes]
+  };
+}
+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(path11.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 fs11.readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const absolutePath = path11.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 = path11.relative(cwd, file);
+  const isExternal = relative.startsWith("..") || path11.isAbsolute(relative);
+  if (isExternal) {
+    const sanitized = file.replace(/[:/\\]+/g, "_");
+    return path11.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 = path11.relative(cwd, file);
+  if (!relative.startsWith("..") && !path11.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);
+    const inInclude = includePatterns.length === 0 || includePatterns.some((pattern) => pattern.test(normalized));
+    if (!inInclude) {
+      return false;
+    }
+    const inExclude = excludePatterns.some((pattern) => pattern.test(normalized));
+    return !inExclude;
+  });
+}
+async function migrateConfigFiles(options) {
+  const cwd = path11.resolve(options.cwd);
+  const dryRun = options.dryRun ?? false;
+  const rollbackOnError = options.rollbackOnError ?? true;
+  const backupDirectory = options.backupDir ? path11.resolve(cwd, options.backupDir) : void 0;
+  const maxDepth = options.maxDepth ?? DEFAULT_WORKSPACE_MAX_DEPTH;
+  const discoveredTargetFiles = options.files && options.files.length > 0 ? resolveTargetFiles(cwd, options.files) : options.workspace ? await collectWorkspaceConfigFiles(cwd, maxDepth) : resolveTargetFiles(cwd);
+  const targetFiles = filterTargetFiles(discoveredTargetFiles, cwd, options.include, options.exclude);
+  const entries = [];
+  let scannedFiles = 0;
+  let changedFiles = 0;
+  let writtenFiles = 0;
+  let backupsWritten = 0;
+  let unchangedFiles = 0;
+  let missingFiles = 0;
+  const wroteEntries = [];
+  for (const file of targetFiles) {
+    const exists = await fs11.pathExists(file);
+    if (!exists) {
+      missingFiles += 1;
+      continue;
+    }
+    scannedFiles += 1;
+    const source = await fs11.readFile(file, "utf8");
+    const migrated = migrateConfigSource(source);
+    const entry = {
+      file,
+      changed: migrated.changed,
+      written: false,
+      rolledBack: false,
+      changes: migrated.changes
+    };
+    entries.push(entry);
+    if (migrated.changed) {
+      changedFiles += 1;
+      if (!dryRun) {
+        try {
+          if (backupDirectory) {
+            const backupRelativePath = resolveBackupRelativePath(cwd, file);
+            const backupFile = path11.resolve(backupDirectory, backupRelativePath);
+            await fs11.ensureDir(path11.dirname(backupFile));
+            await fs11.writeFile(backupFile, source, "utf8");
+            entry.backupFile = backupFile;
+            backupsWritten += 1;
+          }
+          await fs11.writeFile(file, migrated.code, "utf8");
+          entry.written = true;
+          wroteEntries.push({ file, source, entry });
+          writtenFiles += 1;
+        } catch (error) {
+          let rollbackCount = 0;
+          if (rollbackOnError && wroteEntries.length > 0) {
+            for (const written of [...wroteEntries].reverse()) {
+              try {
+                await fs11.writeFile(written.file, written.source, "utf8");
+                written.entry.written = false;
+                written.entry.rolledBack = true;
+                rollbackCount += 1;
+              } catch {
+              }
+            }
+            writtenFiles = Math.max(0, writtenFiles - rollbackCount);
+          }
+          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}`);
+        }
+      }
+    } else {
+      unchangedFiles += 1;
+    }
+  }
+  return {
+    reportKind: MIGRATION_REPORT_KIND,
+    schemaVersion: MIGRATION_REPORT_SCHEMA_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tool: {
+      name: pkgName,
+      version: pkgVersion
+    },
+    cwd,
+    dryRun,
+    rollbackOnError,
+    ...backupDirectory ? { backupDirectory } : {},
+    scannedFiles,
+    changedFiles,
+    writtenFiles,
+    backupsWritten,
+    unchangedFiles,
+    missingFiles,
+    entries
+  };
+}
+async function restoreConfigFiles(options) {
+  const cwd = path11.resolve(options.cwd);
+  const dryRun = options.dryRun ?? false;
+  const strict = options.strict ?? false;
+  const reportFile = path11.resolve(cwd, options.reportFile);
+  const report = await fs11.readJSON(reportFile);
+  if (report.reportKind !== void 0 && report.reportKind !== MIGRATION_REPORT_KIND) {
+    throw new Error(`Unsupported report kind "${report.reportKind}" in ${reportFile}.`);
+  }
+  if (report.schemaVersion !== void 0 && (!Number.isInteger(report.schemaVersion) || report.schemaVersion > MIGRATION_REPORT_SCHEMA_VERSION)) {
+    throw new Error(
+      `Unsupported report schema version "${String(report.schemaVersion)}" in ${reportFile}. Current supported version is ${MIGRATION_REPORT_SCHEMA_VERSION}.`
+    );
+  }
+  const entries = Array.isArray(report.entries) ? report.entries : [];
+  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 ? path11.resolve(entry.file) : void 0;
+    const backupFile = entry.backupFile ? path11.resolve(entry.backupFile) : void 0;
+    if (!targetFile || !backupFile) {
+      skippedEntries += 1;
+      continue;
+    }
+    restorableEntries += 1;
+    const backupExists = await fs11.pathExists(backupFile);
+    if (!backupExists) {
+      missingBackups += 1;
+      continue;
+    }
+    if (!dryRun) {
+      const backupContent = await fs11.readFile(backupFile, "utf8");
+      await fs11.ensureDir(path11.dirname(targetFile));
+      await fs11.writeFile(targetFile, backupContent, "utf8");
+    }
+    restoredFiles += 1;
+    restored.push(targetFile);
+  }
+  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
+  };
+}
+
+// src/cli/commands.ts
+import process7 from "process";
+import { CONFIG_NAME, getConfig, initConfig } from "@tailwindcss-mangle/config";
+
+// ../../node_modules/.pnpm/defu@6.1.4/node_modules/defu/dist/defu.mjs
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+var defu = createDefu();
+var defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+var defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+// ../shared/src/utils.ts
+var defuOverrideArray = createDefu((obj, key, value) => {
+  if (Array.isArray(obj[key]) && Array.isArray(value)) {
+    obj[key] = value;
+    return true;
+  }
+});
+var preserveClassNames = [
+  // https://tailwindcss.com/docs/transition-timing-function start
+  // https://github.com/sonofmagic/tailwindcss-mangle/issues/21
+  "ease-out",
+  "ease-linear",
+  "ease-in",
+  "ease-in-out"
+  // https://tailwindcss.com/docs/transition-timing-function end
+];
+var preserveClassNamesMap = preserveClassNames.reduce((acc, cur) => {
+  acc[cur] = true;
+  return acc;
+}, {});
+var acceptChars = [..."abcdefghijklmnopqrstuvwxyz"];
+
+// src/cli/commands.ts
+import cac from "cac";
+import fs12 from "fs-extra";
+import path12 from "pathe";
+var tailwindcssPatchCommands = ["install", "extract", "tokens", "init", "migrate", "restore", "validate", "status"];
+var VALIDATE_EXIT_CODES = {
+  OK: 0,
+  REPORT_INCOMPATIBLE: 21,
+  MISSING_BACKUPS: 22,
+  IO_ERROR: 23,
+  UNKNOWN_ERROR: 24
+};
+var VALIDATE_FAILURE_REASONS = [
+  "report-incompatible",
+  "missing-backups",
+  "io-error",
+  "unknown-error"
+];
+var IO_ERROR_CODES = /* @__PURE__ */ 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;
+  }
+};
+var TOKEN_FORMATS = ["json", "lines", "grouped-json"];
+var DEFAULT_TOKEN_REPORT = ".tw-patch/tw-token-report.json";
+function formatTokenLine(entry) {
+  return `${entry.relativeFile}:${entry.line}:${entry.column} ${entry.rawCandidate} (${entry.start}-${entry.end})`;
+}
+function formatGroupedPreview(map, limit = 3) {
+  const files = Object.keys(map);
+  if (!files.length) {
+    return { preview: "", moreFiles: 0 };
+  }
+  const lines = files.slice(0, limit).map((file) => {
+    const tokens = map[file] ?? [];
+    const sample = tokens.slice(0, 3).map((token) => token.rawCandidate).join(", ");
+    const suffix = tokens.length > 3 ? ", \u2026" : "";
+    return `${file}: ${tokens.length} tokens (${sample}${suffix})`;
+  });
+  return {
+    preview: lines.join("\n"),
+    moreFiles: Math.max(0, files.length - limit)
+  };
+}
+function resolveCwd(rawCwd) {
+  if (!rawCwd) {
+    return process7.cwd();
+  }
+  return path12.resolve(rawCwd);
+}
+function createDefaultRunner(factory) {
+  let promise;
+  return () => {
+    if (!promise) {
+      promise = factory();
+    }
+    return promise;
+  };
+}
+async function loadPatchOptionsForCwd(cwd, overrides) {
+  const { config } = await getConfig(cwd);
+  const legacyConfig = config;
+  const base = config?.registry ? fromUnifiedConfig(config.registry) : legacyConfig?.patch ? fromLegacyOptions({ patch: legacyConfig.patch }) : {};
+  const merged = defu(overrides ?? {}, base);
+  return merged;
+}
+function createCommandContext(cli, command, commandName, args, cwd) {
+  let cachedOptions;
+  let cachedPatcher;
+  let cachedConfig;
+  const loadPatchOptionsForContext = (overrides) => {
+    if (overrides) {
+      return loadPatchOptionsForCwd(cwd, overrides);
+    }
+    if (!cachedOptions) {
+      cachedOptions = loadPatchOptionsForCwd(cwd);
+    }
+    return cachedOptions;
+  };
+  const createPatcherForContext = async (overrides) => {
+    if (overrides) {
+      const patchOptions = await loadPatchOptionsForCwd(cwd, overrides);
+      return new TailwindcssPatcher(patchOptions);
+    }
+    if (!cachedPatcher) {
+      cachedPatcher = loadPatchOptionsForContext().then((options) => new TailwindcssPatcher(options));
+    }
+    return cachedPatcher;
+  };
+  return {
+    cli,
+    command,
+    commandName,
+    args,
+    cwd,
+    logger: logger_default,
+    loadConfig: () => {
+      if (!cachedConfig) {
+        cachedConfig = getConfig(cwd);
+      }
+      return cachedConfig;
+    },
+    loadPatchOptions: loadPatchOptionsForContext,
+    createPatcher: createPatcherForContext
+  };
+}
+function createCwdOptionDefinition(description = "Working directory") {
+  return {
+    flags: "--cwd <dir>",
+    description,
+    config: { default: process7.cwd() }
+  };
+}
+function buildDefaultCommandDefinitions() {
+  return {
+    install: {
+      description: "Apply Tailwind CSS runtime patches",
+      optionDefs: [createCwdOptionDefinition()]
+    },
+    extract: {
+      description: "Collect generated class names into a cache file",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path" },
+        { flags: "--format <format>", description: "Output format (json|lines)" },
+        { flags: "--css <file>", description: "Tailwind CSS entry CSS when using v4" },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    tokens: {
+      description: "Extract Tailwind tokens with file/position metadata",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--output <file>", description: "Override output file path", config: { default: DEFAULT_TOKEN_REPORT } },
+        {
+          flags: "--format <format>",
+          description: "Output format (json|lines|grouped-json)",
+          config: { default: "json" }
+        },
+        {
+          flags: "--group-key <key>",
+          description: "Grouping key for grouped-json output (relative|absolute)",
+          config: { default: "relative" }
+        },
+        { flags: "--no-write", description: "Skip writing to disk" }
+      ]
+    },
+    init: {
+      description: "Generate a tailwindcss-patch config file",
+      optionDefs: [createCwdOptionDefinition()]
+    },
+    migrate: {
+      description: "Migrate deprecated config fields to modern options",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--config <file>", description: "Migrate a specific config file path" },
+        { flags: "--workspace", description: "Scan workspace recursively for config files" },
+        { flags: "--max-depth <n>", description: "Maximum recursion depth for --workspace", config: { default: 6 } },
+        { flags: "--include <glob>", description: "Only migrate files that match this glob (repeatable)" },
+        { flags: "--exclude <glob>", description: "Skip files that match this glob (repeatable)" },
+        { flags: "--report-file <file>", description: "Write migration report JSON to a file" },
+        { flags: "--backup-dir <dir>", description: "Write pre-migration backups into this directory" },
+        { flags: "--check", description: "Exit with an error when migration changes are required" },
+        { flags: "--json", description: "Print the migration report as JSON" },
+        { flags: "--dry-run", description: "Preview changes without writing files" }
+      ]
+    },
+    restore: {
+      description: "Restore config files from a previous migration report backup snapshot",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--report-file <file>", description: "Migration report file generated by migrate" },
+        { flags: "--dry-run", description: "Preview restore targets without writing files" },
+        { flags: "--strict", description: "Fail when any backup file is missing" },
+        { flags: "--json", description: "Print the restore result as JSON" }
+      ]
+    },
+    validate: {
+      description: "Validate migration report compatibility without modifying files",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--report-file <file>", description: "Migration report file to validate" },
+        { flags: "--strict", description: "Fail when any backup file is missing" },
+        { flags: "--json", description: "Print validation result as JSON" }
+      ]
+    },
+    status: {
+      description: "Check which Tailwind patches are applied",
+      optionDefs: [
+        createCwdOptionDefinition(),
+        { flags: "--json", description: "Print a JSON report of patch status" }
+      ]
+    }
+  };
+}
+function addPrefixIfMissing(value, prefix) {
+  if (!prefix || value.startsWith(prefix)) {
+    return value;
+  }
+  return `${prefix}${value}`;
+}
+function resolveCommandNames(command, mountOptions, prefix) {
+  const override = mountOptions.commandOptions?.[command];
+  const baseName = override?.name ?? command;
+  const name = addPrefixIfMissing(baseName, prefix);
+  const aliases = (override?.aliases ?? []).map((alias) => addPrefixIfMissing(alias, prefix));
+  return { name, aliases };
+}
+function resolveOptionDefinitions(defaults, override) {
+  if (!override) {
+    return defaults;
+  }
+  const appendDefaults = override.appendDefaultOptions ?? true;
+  const customDefs = override.optionDefs ?? [];
+  if (!appendDefaults) {
+    return customDefs;
+  }
+  if (customDefs.length === 0) {
+    return defaults;
+  }
+  return [...defaults, ...customDefs];
+}
+function applyCommandOptions(command, optionDefs) {
+  for (const option of optionDefs) {
+    command.option(option.flags, option.description ?? "", option.config);
+  }
+}
+function runWithCommandHandler(cli, command, commandName, args, handler, defaultHandler) {
+  const cwd = resolveCwd(args.cwd);
+  const context = createCommandContext(cli, command, commandName, args, cwd);
+  const runDefault = createDefaultRunner(() => defaultHandler(context));
+  if (!handler) {
+    return runDefault();
+  }
+  return handler(context, runDefault);
+}
+function resolveCommandMetadata(command, mountOptions, prefix, defaults) {
+  const names = resolveCommandNames(command, mountOptions, prefix);
+  const definition = defaults[command];
+  const override = mountOptions.commandOptions?.[command];
+  const description = override?.description ?? definition.description;
+  const optionDefs = resolveOptionDefinitions(definition.optionDefs, override);
+  return { ...names, description, optionDefs };
+}
+async function installCommandDefaultHandler(ctx) {
+  const patcher = await ctx.createPatcher();
+  await patcher.patch();
+  logger_default.success("Tailwind CSS runtime patched successfully.");
+}
+async function extractCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const overrides = {};
+  let hasOverrides = false;
+  if (args.output || args.format) {
+    overrides.extract = {
+      ...args.output === void 0 ? {} : { file: args.output },
+      ...args.format === void 0 ? {} : { format: args.format }
+    };
+    hasOverrides = true;
+  }
+  if (args.css) {
+    overrides.tailwindcss = {
+      v4: {
+        cssEntries: [args.css]
+      }
+    };
+    hasOverrides = true;
+  }
+  const patcher = await ctx.createPatcher(hasOverrides ? overrides : void 0);
+  const extractOptions = args.write === void 0 ? {} : { write: args.write };
+  const result = await patcher.extract(extractOptions);
+  if (result.filename) {
+    logger_default.success(`Collected ${result.classList.length} classes \u2192 ${result.filename}`);
+  } else {
+    logger_default.success(`Collected ${result.classList.length} classes.`);
+  }
+  return result;
+}
+async function tokensCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const patcher = await ctx.createPatcher();
+  const report = await patcher.collectContentTokens();
+  const shouldWrite = args.write ?? true;
+  let format = args.format ?? "json";
+  if (!TOKEN_FORMATS.includes(format)) {
+    format = "json";
+  }
+  const targetFile = args.output ?? DEFAULT_TOKEN_REPORT;
+  const groupKey = args.groupKey === "absolute" ? "absolute" : "relative";
+  const buildGrouped = () => groupTokensByFile(report, {
+    key: groupKey,
+    stripAbsolutePaths: groupKey !== "absolute"
+  });
+  const grouped = format === "grouped-json" ? buildGrouped() : null;
+  const resolveGrouped = () => grouped ?? buildGrouped();
+  if (shouldWrite) {
+    const target = path12.resolve(targetFile);
+    await fs12.ensureDir(path12.dirname(target));
+    if (format === "json") {
+      await fs12.writeJSON(target, report, { spaces: 2 });
+    } else if (format === "grouped-json") {
+      await fs12.writeJSON(target, resolveGrouped(), { spaces: 2 });
+    } else {
+      const lines = report.entries.map(formatTokenLine);
+      await fs12.writeFile(target, `${lines.join("\n")}
+`, "utf8");
+    }
+    logger_default.success(`Collected ${report.entries.length} tokens (${format}) \u2192 ${target.replace(process7.cwd(), ".")}`);
+  } else {
+    logger_default.success(`Collected ${report.entries.length} tokens from ${report.filesScanned} files.`);
+    if (format === "lines") {
+      const preview = report.entries.slice(0, 5).map(formatTokenLine).join("\n");
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (report.entries.length > 5) {
+          logger_default.info(`\u2026and ${report.entries.length - 5} more.`);
+        }
+      }
+    } else if (format === "grouped-json") {
+      const map = resolveGrouped();
+      const { preview, moreFiles } = formatGroupedPreview(map);
+      if (preview) {
+        logger_default.log("");
+        logger_default.info(preview);
+        if (moreFiles > 0) {
+          logger_default.info(`\u2026and ${moreFiles} more files.`);
+        }
+      }
+    } else {
+      const previewEntries = report.entries.slice(0, 3);
+      if (previewEntries.length) {
+        logger_default.log("");
+        logger_default.info(JSON.stringify(previewEntries, null, 2));
+      }
+    }
+  }
+  if (report.skippedFiles.length) {
+    logger_default.warn("Skipped files:");
+    for (const skipped of report.skippedFiles) {
+      logger_default.warn(`  \u2022 ${skipped.file} (${skipped.reason})`);
+    }
+  }
+  return report;
+}
+async function initCommandDefaultHandler(ctx) {
+  await initConfig(ctx.cwd);
+  logger_default.success(`\u2728 ${CONFIG_NAME}.config.ts initialized!`);
+}
+async function migrateCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const normalizePatternArgs = (value) => {
+    if (!value) {
+      return void 0;
+    }
+    const raw = Array.isArray(value) ? value : [value];
+    const values = raw.flatMap((item) => item.split(",")).map((item) => item.trim()).filter(Boolean);
+    return values.length > 0 ? values : void 0;
+  };
+  const include = normalizePatternArgs(args.include);
+  const exclude = normalizePatternArgs(args.exclude);
+  const parsedMaxDepth = args.maxDepth === void 0 ? void 0 : Number(args.maxDepth);
+  const maxDepth = parsedMaxDepth !== void 0 && Number.isFinite(parsedMaxDepth) && parsedMaxDepth >= 0 ? Math.floor(parsedMaxDepth) : void 0;
+  const checkMode = args.check ?? false;
+  const dryRun = args.dryRun ?? checkMode;
+  if (args.workspace && args.maxDepth !== void 0 && maxDepth === void 0) {
+    logger_default.warn(`Invalid --max-depth value "${String(args.maxDepth)}", fallback to default depth.`);
+  }
+  const report = await migrateConfigFiles({
+    cwd: ctx.cwd,
+    dryRun,
+    ...args.config ? { files: [args.config] } : {},
+    ...args.workspace ? { workspace: true } : {},
+    ...args.workspace && maxDepth !== void 0 ? { maxDepth } : {},
+    ...args.backupDir ? { backupDir: args.backupDir } : {},
+    ...include ? { include } : {},
+    ...exclude ? { exclude } : {}
+  });
+  if (args.reportFile) {
+    const reportPath = path12.resolve(ctx.cwd, args.reportFile);
+    await fs12.ensureDir(path12.dirname(reportPath));
+    await fs12.writeJSON(reportPath, report, { spaces: 2 });
+    logger_default.info(`Migration report written: ${reportPath.replace(process7.cwd(), ".")}`);
+  }
+  if (args.json) {
+    logger_default.log(JSON.stringify(report, null, 2));
+    if (checkMode && report.changedFiles > 0) {
+      throw new Error(`Migration check failed: ${report.changedFiles} file(s) still need migration.`);
+    }
+    if (report.scannedFiles === 0) {
+      logger_default.warn("No config files found for migration.");
+    }
+    return report;
+  }
+  if (report.scannedFiles === 0) {
+    logger_default.warn("No config files found for migration.");
+    return report;
+  }
+  for (const entry of report.entries) {
+    const fileLabel = entry.file.replace(process7.cwd(), ".");
+    if (!entry.changed) {
+      logger_default.info(`No changes: ${fileLabel}`);
+      continue;
+    }
+    if (dryRun) {
+      logger_default.info(`[dry-run] ${fileLabel}`);
+    } else {
+      logger_default.success(`Migrated: ${fileLabel}`);
+    }
+    for (const change of entry.changes) {
+      logger_default.info(`  - ${change}`);
+    }
+    if (entry.backupFile) {
+      logger_default.info(`  - backup: ${entry.backupFile.replace(process7.cwd(), ".")}`);
+    }
+  }
+  logger_default.info(
+    `Migration summary: scanned=${report.scannedFiles}, changed=${report.changedFiles}, written=${report.writtenFiles}, backups=${report.backupsWritten}, missing=${report.missingFiles}, unchanged=${report.unchangedFiles}`
+  );
+  if (checkMode && report.changedFiles > 0) {
+    throw new Error(`Migration check failed: ${report.changedFiles} file(s) still need migration.`);
+  }
+  return report;
+}
+async function restoreCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const reportFile = args.reportFile ?? ".tw-patch/migrate-report.json";
+  const result = await restoreConfigFiles({
+    cwd: ctx.cwd,
+    reportFile,
+    dryRun: args.dryRun ?? false,
+    strict: args.strict ?? false
+  });
+  if (args.json) {
+    logger_default.log(JSON.stringify(result, null, 2));
+    return result;
+  }
+  logger_default.info(
+    `Restore summary: scanned=${result.scannedEntries}, restorable=${result.restorableEntries}, restored=${result.restoredFiles}, missingBackups=${result.missingBackups}, skipped=${result.skippedEntries}`
+  );
+  if (result.restored.length > 0) {
+    const preview = result.restored.slice(0, 5);
+    for (const file of preview) {
+      logger_default.info(`  - ${file.replace(process7.cwd(), ".")}`);
+    }
+    if (result.restored.length > preview.length) {
+      logger_default.info(`  ...and ${result.restored.length - preview.length} more`);
+    }
+  }
+  return result;
+}
+async function validateCommandDefaultHandler(ctx) {
+  const { args } = ctx;
+  const reportFile = args.reportFile ?? ".tw-patch/migrate-report.json";
+  try {
+    const result = await restoreConfigFiles({
+      cwd: ctx.cwd,
+      reportFile,
+      dryRun: true,
+      strict: args.strict ?? false
+    });
+    if (args.json) {
+      const payload = {
+        ok: true,
+        ...result
+      };
+      logger_default.log(JSON.stringify(payload, null, 2));
+      return result;
+    }
+    logger_default.success(
+      `Migration report validated: scanned=${result.scannedEntries}, restorable=${result.restorableEntries}, missingBackups=${result.missingBackups}, skipped=${result.skippedEntries}`
+    );
+    if (result.reportKind || result.reportSchemaVersion !== void 0) {
+      const kind = result.reportKind ?? "unknown";
+      const schema = result.reportSchemaVersion === void 0 ? "unknown" : String(result.reportSchemaVersion);
+      logger_default.info(`  metadata: kind=${kind}, schema=${schema}`);
+    }
+    return result;
+  } catch (error) {
+    const summary = classifyValidateError(error);
+    if (args.json) {
+      const payload = {
+        ok: false,
+        reason: summary.reason,
+        exitCode: summary.exitCode,
+        message: summary.message
+      };
+      logger_default.log(JSON.stringify(payload, null, 2));
+    } else {
+      logger_default.error(`Validation failed [${summary.reason}] (exit ${summary.exitCode}): ${summary.message}`);
+    }
+    throw new ValidateCommandError(summary, { cause: error });
+  }
+}
+function formatFilesHint(entry) {
+  if (!entry.files.length) {
+    return "";
+  }
+  return ` (${entry.files.join(", ")})`;
+}
+async function statusCommandDefaultHandler(ctx) {
+  const patcher = await ctx.createPatcher();
+  const report = await patcher.getPatchStatus();
+  if (ctx.args.json) {
+    logger_default.log(JSON.stringify(report, null, 2));
+    return report;
+  }
+  const applied = report.entries.filter((entry) => entry.status === "applied");
+  const pending = report.entries.filter((entry) => entry.status === "not-applied");
+  const skipped = report.entries.filter((entry) => entry.status === "skipped" || entry.status === "unsupported");
+  const packageLabel = `${report.package.name ?? "tailwindcss"}@${report.package.version ?? "unknown"}`;
+  logger_default.info(`Patch status for ${packageLabel} (v${report.majorVersion})`);
+  if (applied.length) {
+    logger_default.success("Applied:");
+    applied.forEach((entry) => logger_default.success(`  \u2022 ${entry.name}${formatFilesHint(entry)}`));
+  }
+  if (pending.length) {
+    logger_default.warn("Needs attention:");
+    pending.forEach((entry) => {
+      const details = entry.reason ? ` \u2013 ${entry.reason}` : "";
+      logger_default.warn(`  \u2022 ${entry.name}${formatFilesHint(entry)}${details}`);
+    });
+  } else {
+    logger_default.success("All applicable patches are applied.");
+  }
+  if (skipped.length) {
+    logger_default.info("Skipped:");
+    skipped.forEach((entry) => {
+      const details = entry.reason ? ` \u2013 ${entry.reason}` : "";
+      logger_default.info(`  \u2022 ${entry.name}${details}`);
+    });
+  }
+  return report;
+}
+function mountTailwindcssPatchCommands(cli, options = {}) {
+  const prefix = options.commandPrefix ?? "";
+  const selectedCommands = options.commands ?? tailwindcssPatchCommands;
+  const defaultDefinitions = buildDefaultCommandDefinitions();
+  const registrars = {
+    install: () => {
+      const metadata = resolveCommandMetadata("install", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "install",
+          args,
+          options.commandHandlers?.install,
+          installCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    extract: () => {
+      const metadata = resolveCommandMetadata("extract", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "extract",
+          args,
+          options.commandHandlers?.extract,
+          extractCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    tokens: () => {
+      const metadata = resolveCommandMetadata("tokens", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "tokens",
+          args,
+          options.commandHandlers?.tokens,
+          tokensCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    init: () => {
+      const metadata = resolveCommandMetadata("init", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "init",
+          args,
+          options.commandHandlers?.init,
+          initCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    migrate: () => {
+      const metadata = resolveCommandMetadata("migrate", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "migrate",
+          args,
+          options.commandHandlers?.migrate,
+          migrateCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    restore: () => {
+      const metadata = resolveCommandMetadata("restore", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "restore",
+          args,
+          options.commandHandlers?.restore,
+          restoreCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    validate: () => {
+      const metadata = resolveCommandMetadata("validate", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "validate",
+          args,
+          options.commandHandlers?.validate,
+          validateCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    },
+    status: () => {
+      const metadata = resolveCommandMetadata("status", options, prefix, defaultDefinitions);
+      const command = cli.command(metadata.name, metadata.description);
+      applyCommandOptions(command, metadata.optionDefs);
+      command.action(async (args) => {
+        return runWithCommandHandler(
+          cli,
+          command,
+          "status",
+          args,
+          options.commandHandlers?.status,
+          statusCommandDefaultHandler
+        );
+      });
+      metadata.aliases.forEach((alias) => command.alias(alias));
+    }
+  };
+  for (const name of selectedCommands) {
+    const register = registrars[name];
+    if (register) {
+      register();
+    }
+  }
+  return cli;
+}
+function createTailwindcssPatchCli(options = {}) {
+  const cli = cac(options.name ?? "tw-patch");
+  mountTailwindcssPatchCommands(cli, options.mountOptions);
+  return cli;
+}
+
+export {
+  logger_default,
+  CacheStore,
+  extractRawCandidatesWithPositions,
+  extractRawCandidates,
+  extractValidCandidates,
+  extractProjectCandidatesWithPositions,
+  groupTokensByFile,
+  normalizeOptions,
+  getPatchStatusReport,
+  collectClassesFromContexts,
+  collectClassesFromTailwindV4,
+  loadRuntimeContexts,
+  runTailwindBuild,
+  TailwindcssPatcher,
+  MIGRATION_REPORT_KIND,
+  MIGRATION_REPORT_SCHEMA_VERSION,
+  migrateConfigFiles,
+  restoreConfigFiles,
+  tailwindcssPatchCommands,
+  VALIDATE_EXIT_CODES,
+  VALIDATE_FAILURE_REASONS,
+  ValidateCommandError,
+  mountTailwindcssPatchCommands,
+  createTailwindcssPatchCli
+};