tailwindcss-patch 9.0.0-alpha.5 → 9.0.1

package/dist/chunk-4BA7N3QJ.mjs

@@ -1,4378 +0,0 @@
-import {
-  __dirname
-} from "./chunk-OSH52QWA.mjs";
-
-// 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: "9.0.0-alpha.5",
-  description: "patch tailwindcss for exposing context and extract classes",
-  author: "ice breaker <1324318532@qq.com>",
-  license: "MIT",
-  engines: {
-    node: ">=18.0.0"
-  },
-  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",
-    "src"
-  ],
-  scripts: {
-    dev: "tsup --watch --sourcemap",
-    build: "tsup",
-    test: "vitest run",
-    "test:types": "pnpm build && tsd --typings dist/index.d.mts --files test-d/**/*.test-d.ts",
-    "test:dev": "vitest",
-    "bench:cold-start": "node --import tsx bench/cold-start.ts",
-    patch: "tsx dev/bin.ts install",
-    r0: "tsx dev/bin.ts extract",
-    r1: "tsx dev/bin.ts extract --css index.css"
-  },
-  tsd: {
-    directory: "test-d"
-  },
-  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.2",
-    "@babel/traverse": "^7.29.0",
-    "@babel/types": "^7.29.0",
-    "@tailwindcss-mangle/config": "workspace:*",
-    "@tailwindcss/node": "^4.2.2",
-    cac: "6.7.14",
-    consola: "^3.4.2",
-    "fs-extra": "^11.3.4",
-    "local-pkg": "^1.1.2",
-    pathe: "^2.0.3",
-    postcss: "^8.5.8",
-    semver: "^7.7.4",
-    "tailwindcss-config": "^1.1.4"
-  },
-  devDependencies: {
-    "@tailwindcss/oxide": "^4.2.2",
-    "@tailwindcss/postcss": "^4.2.2",
-    "@tailwindcss/vite": "^4.2.2",
-    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/options/normalize.ts
-import process3 from "process";
-import fs3 from "fs-extra";
-import path2 from "pathe";
-function resolveRealpathSafe(value) {
-  const resolved = path2.resolve(value);
-  try {
-    return path2.normalize(fs3.realpathSync(resolved));
-  } catch {
-    return path2.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 = path2.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 ? path2.resolve(cache.dir) : path2.resolve(cwd, "node_modules/.cache", pkgName);
-    file = cache.file ?? file;
-    strategy = cache.strategy ?? strategy;
-    driver = normalizeCacheDriver(cache.driver);
-  }
-  const filename = path2.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 ? path2.resolve(v4.base) : void 0;
-  const base = configuredBase ?? fallbackBase;
-  const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => path2.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
-  };
-}
-var deprecatedOptionMapping = {
-  cwd: "projectRoot",
-  overwrite: "apply.overwrite",
-  tailwind: "tailwindcss",
-  features: "apply",
-  output: "extract"
-};
-function assertNoDeprecatedOptions(options) {
-  const used = Object.keys(deprecatedOptionMapping).filter((key) => Object.prototype.hasOwnProperty.call(options, key));
-  if (used.length === 0) {
-    return;
-  }
-  const mapping = used.map((key) => `${key} -> ${deprecatedOptionMapping[key]}`).join(", ");
-  throw new Error(
-    `Legacy TailwindcssPatcher options are no longer supported: ${used.join(", ")}. Use the modern fields instead: ${mapping}.`
-  );
-}
-function normalizeOptions(options = {}) {
-  assertNoDeprecatedOptions(options);
-  const projectRoot = resolveRealpathSafe(options.projectRoot ? path2.resolve(options.projectRoot) : process3.cwd());
-  const overwrite = options.apply?.overwrite ?? true;
-  const output = normalizeOutputOptions(options.extract);
-  const cache = normalizeCacheOptions(options.cache, projectRoot);
-  const tailwind = normalizeTailwindOptions(options.tailwindcss, projectRoot);
-  const exposeContext = normalizeExposeContextOptions(options.apply?.exposeContext);
-  const extendLengthUnits = normalizeExtendLengthUnitsOptions(options.apply?.extendLengthUnits);
-  const filter = (className) => {
-    if (output.removeUniversalSelector && className === "*") {
-      return false;
-    }
-    if (typeof options.filter === "function") {
-      return options.filter(className) !== false;
-    }
-    return true;
-  };
-  return {
-    projectRoot,
-    overwrite,
-    tailwind,
-    features: {
-      exposeContext,
-      extendLengthUnits
-    },
-    output,
-    cache,
-    filter
-  };
-}
-
-// src/options/legacy.ts
-var deprecatedRegistryMapping = {
-  output: "extract",
-  tailwind: "tailwindcss"
-};
-var deprecatedTailwindMapping = {
-  package: "packageName",
-  legacy: "v2",
-  classic: "v3",
-  next: "v4"
-};
-function assertNoDeprecatedRegistryOptions(registry) {
-  const usedRegistryKeys = Object.keys(deprecatedRegistryMapping).filter((key) => Object.prototype.hasOwnProperty.call(registry, key));
-  if (usedRegistryKeys.length > 0) {
-    const mapping = usedRegistryKeys.map((key) => `${key} -> ${deprecatedRegistryMapping[key]}`).join(", ");
-    throw new Error(
-      `Legacy registry fields are no longer supported: ${usedRegistryKeys.join(", ")}. Use the modern fields instead: ${mapping}.`
-    );
-  }
-  const tailwind = registry.tailwindcss;
-  if (!tailwind) {
-    return;
-  }
-  const usedTailwindKeys = Object.keys(deprecatedTailwindMapping).filter((key) => Object.prototype.hasOwnProperty.call(tailwind, key));
-  if (usedTailwindKeys.length > 0) {
-    const mapping = usedTailwindKeys.map((key) => `${key} -> tailwindcss.${deprecatedTailwindMapping[key]}`).join(", ");
-    throw new Error(
-      `Legacy "registry.tailwindcss" fields are no longer supported: ${usedTailwindKeys.join(", ")}. Use the modern fields instead: ${mapping}.`
-    );
-  }
-}
-function fromUnifiedConfig(registry) {
-  if (!registry) {
-    return {};
-  }
-  assertNoDeprecatedRegistryOptions(registry);
-  const extract = registry.extract ? {
-    ...registry.extract.write === void 0 ? {} : { write: registry.extract.write },
-    ...registry.extract.file === void 0 ? {} : { file: registry.extract.file },
-    ...registry.extract.format === void 0 ? {} : { format: registry.extract.format },
-    ...registry.extract.pretty === void 0 ? {} : { pretty: registry.extract.pretty },
-    ...registry.extract.removeUniversalSelector === void 0 ? {} : { removeUniversalSelector: registry.extract.removeUniversalSelector }
-  } : void 0;
-  const tailwindcss = registry.tailwindcss ? {
-    ...registry.tailwindcss.version === void 0 ? {} : { version: registry.tailwindcss.version },
-    ...registry.tailwindcss.packageName === void 0 ? {} : { packageName: registry.tailwindcss.packageName },
-    ...registry.tailwindcss.resolve === void 0 ? {} : { resolve: registry.tailwindcss.resolve },
-    ...registry.tailwindcss.config === void 0 ? {} : { config: registry.tailwindcss.config },
-    ...registry.tailwindcss.cwd === void 0 ? {} : { cwd: registry.tailwindcss.cwd },
-    ...registry.tailwindcss.v2 === void 0 ? {} : { v2: registry.tailwindcss.v2 },
-    ...registry.tailwindcss.v3 === void 0 ? {} : { v3: registry.tailwindcss.v3 },
-    ...registry.tailwindcss.v4 === void 0 ? {} : { v4: registry.tailwindcss.v4 }
-  } : void 0;
-  const apply = registry.apply ? {
-    ...registry.apply.overwrite === void 0 ? {} : { overwrite: registry.apply.overwrite },
-    ...registry.apply.exposeContext === void 0 ? {} : { exposeContext: registry.apply.exposeContext },
-    ...registry.apply.extendLengthUnits === void 0 ? {} : { extendLengthUnits: registry.apply.extendLengthUnits }
-  } : void 0;
-  return {
-    ...registry.projectRoot === void 0 ? {} : { projectRoot: registry.projectRoot },
-    ...apply === void 0 ? {} : { apply },
-    ...registry.cache === void 0 ? {} : { cache: registry.cache },
-    ...registry.filter === void 0 ? {} : { filter: registry.filter },
-    ...extract === void 0 ? {} : { extract },
-    ...tailwindcss === void 0 ? {} : { tailwindcss }
-  };
-}
-
-// src/config/workspace.ts
-import { pathToFileURL } from "url";
-import path3 from "pathe";
-var configModulePromise;
-var defuPromise;
-function isNodeError(error) {
-  return !!error && typeof error === "object" && ("code" in error || "message" in error);
-}
-function isMissingModuleError(error, pkgName2) {
-  if (!isNodeError(error)) {
-    return false;
-  }
-  const code = error.code;
-  if (code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND") {
-    return false;
-  }
-  const message = error.message ?? "";
-  return message.includes(pkgName2) || message.includes(`${pkgName2}/dist/`);
-}
-function isMissingConfigModuleError(error) {
-  return isMissingModuleError(error, "@tailwindcss-mangle/config");
-}
-function isMissingSharedModuleError(error) {
-  return isMissingModuleError(error, "@tailwindcss-mangle/shared");
-}
-async function loadWorkspaceConfigModule() {
-  if (!configModulePromise) {
-    configModulePromise = import("@tailwindcss-mangle/config").catch(async (error) => {
-      if (!isMissingConfigModuleError(error)) {
-        throw error;
-      }
-      const fallback = path3.resolve(__dirname, "../../../config/src/index.ts");
-      return import(pathToFileURL(fallback).href);
-    });
-  }
-  return configModulePromise;
-}
-async function loadWorkspaceDefu() {
-  if (!defuPromise) {
-    defuPromise = import("./dist-7W73GIRD.mjs").then((mod) => mod.defu).catch(async (error) => {
-      if (!isMissingSharedModuleError(error)) {
-        throw error;
-      }
-      const fallback = path3.resolve(__dirname, "../../../shared/src/utils.ts");
-      const mod = await import(pathToFileURL(fallback).href);
-      return mod.defu;
-    });
-  }
-  return defuPromise;
-}
-async function loadPatchOptionsForWorkspace(cwd, overrides) {
-  const merge = await loadWorkspaceDefu();
-  const configModule = await loadWorkspaceConfigModule();
-  const { config } = await configModule.getConfig(cwd);
-  if (config && typeof config === "object" && "patch" in config && config.patch !== void 0) {
-    throw new Error('Legacy workspace config field "patch" is no longer supported. Move patcher options under "registry".');
-  }
-  const base = config?.registry ? fromUnifiedConfig(config.registry) : {};
-  const merged = merge(overrides ?? {}, base);
-  return merged;
-}
-
-// src/extraction/candidate-extractor.ts
-import { promises as fs4 } from "fs";
-import process4 from "process";
-import path4 from "pathe";
-var nodeImportPromise;
-var oxideImportPromise;
-var designSystemPromiseCache = /* @__PURE__ */ new Map();
-var designSystemCandidateCache = /* @__PURE__ */ new Map();
-async function importNode() {
-  return import("@tailwindcss/node");
-}
-async function importOxide() {
-  return import("@tailwindcss/oxide");
-}
-function getNodeModule() {
-  nodeImportPromise ??= importNode();
-  return nodeImportPromise;
-}
-function getOxideModule() {
-  oxideImportPromise ??= importOxide();
-  return oxideImportPromise;
-}
-function createDesignSystemCacheKey(css, bases) {
-  return JSON.stringify({
-    css,
-    bases: Array.from(new Set(bases.filter(Boolean)))
-  });
-}
-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 cacheKey = createDesignSystemCacheKey(css, uniqueBases);
-  const cached = designSystemPromiseCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const promise = (async () => {
-    const { __unstable__loadDesignSystem } = await getNodeModule();
-    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.");
-  })();
-  designSystemPromiseCache.set(cacheKey, promise);
-  promise.catch(() => {
-    if (designSystemPromiseCache.get(cacheKey) === promise) {
-      designSystemPromiseCache.delete(cacheKey);
-      designSystemCandidateCache.delete(cacheKey);
-    }
-  });
-  return promise;
-}
-async function extractRawCandidatesWithPositions(content, extension = "html") {
-  const { Scanner } = await getOxideModule();
-  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 getOxideModule();
-  const scanner = new Scanner(sources === void 0 ? {} : { sources });
-  return scanner.scan();
-}
-async function extractValidCandidates(options) {
-  const providedOptions = options ?? {};
-  const defaultCwd = providedOptions.cwd ?? process4.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 designSystemKey = createDesignSystemCacheKey(css, [base, ...baseFallbacks]);
-  const designSystem = await loadDesignSystem(css, [base, ...baseFallbacks]);
-  const candidateCache = designSystemCandidateCache.get(designSystemKey) ?? /* @__PURE__ */ new Map();
-  designSystemCandidateCache.set(designSystemKey, candidateCache);
-  const candidates = await extractRawCandidates(sources);
-  const validCandidates = [];
-  const uncachedCandidates = [];
-  for (const rawCandidate of candidates) {
-    const cached = candidateCache.get(rawCandidate);
-    if (cached === true) {
-      validCandidates.push(rawCandidate);
-      continue;
-    }
-    if (cached === false) {
-      continue;
-    }
-    if (designSystem.parseCandidate(rawCandidate).length > 0) {
-      uncachedCandidates.push(rawCandidate);
-      continue;
-    }
-    candidateCache.set(rawCandidate, false);
-  }
-  if (uncachedCandidates.length === 0) {
-    return validCandidates;
-  }
-  const cssByCandidate = designSystem.candidatesToCss(uncachedCandidates);
-  for (let index = 0; index < uncachedCandidates.length; index++) {
-    const candidate = uncachedCandidates[index];
-    if (candidate === void 0) {
-      continue;
-    }
-    const candidateCss = cssByCandidate[index];
-    const isValid = typeof candidateCss === "string" && candidateCss.trim().length > 0;
-    candidateCache.set(candidate, isValid);
-    if (!isValid) {
-      continue;
-    }
-    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 = path4.extname(filename).replace(/^\./, "");
-  return ext || "txt";
-}
-function toRelativeFile(cwd, filename) {
-  const relative = path4.relative(cwd, filename);
-  return relative === "" ? path4.basename(filename) : relative;
-}
-async function extractProjectCandidatesWithPositions(options) {
-  const cwd = options?.cwd ? path4.resolve(options.cwd) : process4.cwd();
-  const normalizedSources = normalizeSources(options?.sources, cwd);
-  const { Scanner } = await getOxideModule();
-  const scanner = new Scanner({
-    sources: normalizedSources
-  });
-  const files = scanner.files ?? [];
-  const entries = [];
-  const skipped = [];
-  for (const file of files) {
-    let content;
-    try {
-      content = await fs4.readFile(file, "utf8");
-    } catch (error) {
-      skipped.push({
-        file,
-        reason: error instanceof Error ? error.message : "Unknown error"
-      });
-      continue;
-    }
-    const extension = toExtension(file);
-    const matches = scanner.getCandidatesWithPositions({
-      file,
-      content,
-      extension
-    });
-    if (!matches.length) {
-      continue;
-    }
-    const offsets = buildLineOffsets(content);
-    const relativeFile = toRelativeFile(cwd, file);
-    for (const match of matches) {
-      const info = resolveLineMeta(content, offsets, match.position);
-      entries.push({
-        rawCandidate: match.candidate,
-        file,
-        relativeFile,
-        extension,
-        start: match.position,
-        end: match.position + match.candidate.length,
-        length: match.candidate.length,
-        line: info.line,
-        column: info.column,
-        lineText: info.lineText
-      });
-    }
-  }
-  return {
-    entries,
-    filesScanned: files.length,
-    skippedFiles: skipped,
-    sources: normalizedSources
-  };
-}
-function groupTokensByFile(report, options) {
-  const key = options?.key ?? "relative";
-  const stripAbsolute = options?.stripAbsolutePaths ?? key !== "absolute";
-  return report.entries.reduce((acc, entry) => {
-    const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
-    const bucket = acc[bucketKey] ?? (acc[bucketKey] = []);
-    const value = stripAbsolute ? {
-      ...entry,
-      file: entry.relativeFile
-    } : entry;
-    bucket.push(value);
-    return acc;
-  }, {});
-}
-
-// src/runtime/class-collector.ts
-import process5 from "process";
-import fs5 from "fs-extra";
-import path5 from "pathe";
-
-// src/utils.ts
-function isObject(val) {
-  return val !== null && typeof val === "object" && Array.isArray(val) === false;
-}
-function spliceChangesIntoString(str, changes) {
-  const firstChange = changes[0];
-  if (!firstChange) {
-    return str;
-  }
-  changes.sort((a, b) => {
-    return a.end - b.end || a.start - b.start;
-  });
-  let result = "";
-  let previous = firstChange;
-  result += str.slice(0, previous.start);
-  result += previous.replacement;
-  for (let i = 1; i < changes.length; ++i) {
-    const change = changes[i];
-    if (!change) {
-      continue;
-    }
-    result += str.slice(previous.end, change.start);
-    result += change.replacement;
-    previous = change;
-  }
-  result += str.slice(previous.end);
-  return result;
-}
-
-// src/runtime/class-collector.ts
-function collectRuntimeCandidateKeys(context) {
-  const candidateRuleCache = context.candidateRuleCache;
-  if (candidateRuleCache instanceof Map && candidateRuleCache.size > 0) {
-    return candidateRuleCache.keys();
-  }
-  return context.classCache.keys();
-}
-function collectClassesFromContexts(contexts, filter) {
-  const set = /* @__PURE__ */ new Set();
-  for (const context of contexts) {
-    if (!isObject(context) || !context.classCache) {
-      continue;
-    }
-    for (const key of collectRuntimeCandidateKeys(context)) {
-      const className = key.toString();
-      if (filter(className)) {
-        set.add(className);
-      }
-    }
-  }
-  return set;
-}
-async function collectClassesFromTailwindV4(options) {
-  const set = /* @__PURE__ */ new Set();
-  const v4Options = options.tailwind.v4;
-  if (!v4Options) {
-    return set;
-  }
-  const toAbsolute = (value) => {
-    if (!value) {
-      return void 0;
-    }
-    return path5.isAbsolute(value) ? value : path5.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 = path5.isAbsolute(entry) ? entry : path5.resolve(options.projectRoot, entry);
-      if (!await fs5.pathExists(filePath)) {
-        continue;
-      }
-      const css = await fs5.readFile(filePath, "utf8");
-      const entryDir = path5.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 fs6 from "fs-extra";
-import path6 from "pathe";
-var require2 = createRequire(import.meta.url);
-function resolveRuntimeEntry(packageInfo, majorVersion) {
-  const root = packageInfo.rootPath;
-  if (majorVersion === 2) {
-    const jitIndex = path6.join(root, "lib/jit/index.js");
-    if (fs6.existsSync(jitIndex)) {
-      return jitIndex;
-    }
-  } else if (majorVersion === 3) {
-    const plugin = path6.join(root, "lib/plugin.js");
-    const index = path6.join(root, "lib/index.js");
-    if (fs6.existsSync(plugin)) {
-      return plugin;
-    }
-    if (fs6.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 fs7 from "fs-extra";
-import path7 from "pathe";
-import postcss from "postcss";
-import { loadConfig } from "tailwindcss-config";
-var require3 = createRequire2(import.meta.url);
-function resolveModuleEntry(id) {
-  return path7.isAbsolute(id) ? id : require3.resolve(id);
-}
-function resolvePackageRootFromEntry(entry) {
-  let current = path7.dirname(entry);
-  while (current && current !== path7.dirname(current)) {
-    const packageJsonPath = path7.join(current, "package.json");
-    if (fs7.pathExistsSync(packageJsonPath)) {
-      return current;
-    }
-    current = path7.dirname(current);
-  }
-  return void 0;
-}
-function clearTailwindV3RuntimeState(pluginName) {
-  try {
-    const entry = resolveModuleEntry(pluginName);
-    const root = resolvePackageRootFromEntry(entry);
-    if (!root) {
-      return;
-    }
-    const sharedStatePath = path7.join(root, "lib/lib/sharedState.js");
-    if (!fs7.pathExistsSync(sharedStatePath)) {
-      return;
-    }
-    const sharedState = require3.cache[sharedStatePath]?.exports;
-    sharedState?.contextMap?.clear();
-    sharedState?.configContextMap?.clear();
-    sharedState?.contextSourcesMap?.clear();
-    sharedState?.sourceHashMap?.clear();
-    for (const candidate of ["lib/plugin.js", "lib/index.js"]) {
-      const runtimeEntry = path7.join(root, candidate);
-      if (!fs7.pathExistsSync(runtimeEntry)) {
-        continue;
-      }
-      const runtimeModule = require3.cache[runtimeEntry]?.exports;
-      runtimeModule?.contextRef?.value?.splice(0, runtimeModule.contextRef.value.length);
-      break;
-    }
-  } catch {
-  }
-}
-async function resolveConfigPath(options) {
-  if (options.config && path7.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 === 3) {
-    clearTailwindV3RuntimeState(pluginName);
-  }
-  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/patching/status.ts
-import * as t4 from "@babel/types";
-import fs9 from "fs-extra";
-import path9 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(path15) {
-      const node = path15.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(path15) {
-      const program = path15.node;
-      const index = program.body.findIndex((statement) => {
-        return t.isFunctionDeclaration(statement) && statement.id?.name === "_default";
-      });
-      if (index === -1) {
-        return;
-      }
-      const previous = program.body[index - 1];
-      const beforePrevious = program.body[index - 2];
-      const alreadyHasVariable = Boolean(
-        previous && t.isVariableDeclaration(previous) && previous.declarations.length === 1 && (() => {
-          const declaration = previous.declarations[0];
-          return Boolean(
-            declaration && t.isIdentifier(declaration.id) && declaration.id.name === refIdentifier.name
-          );
-        })()
-      );
-      const alreadyAssignsExports = Boolean(
-        beforePrevious && t.isExpressionStatement(beforePrevious) && t.isAssignmentExpression(beforePrevious.expression) && t.isMemberExpression(beforePrevious.expression.left) && t.isIdentifier(beforePrevious.expression.right) && beforePrevious.expression.right.name === refIdentifier.name && generate(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(path15) {
-      if (hasPatched) {
-        return;
-      }
-      const fn = path15.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(path15) {
-      const node = path15.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(path15) {
-      const program = path15.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 && (() => {
-          const declaration = previousStatement.declarations[0];
-          return Boolean(
-            declaration && t2.isIdentifier(declaration.id) && declaration.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(path15) {
-      if (hasPatched) {
-        return;
-      }
-      const fn = path15.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 fs8 from "fs-extra";
-import path8 from "pathe";
-function updateLengthUnitsArray(content, options) {
-  const { variableName = "lengthUnits", units } = options;
-  const ast = parse(content);
-  let arrayRef;
-  let changed = false;
-  traverse(ast, {
-    Identifier(path15) {
-      if (path15.node.name === variableName && t3.isVariableDeclarator(path15.parent) && t3.isArrayExpression(path15.parent.init)) {
-        arrayRef = path15.parent.init;
-        const existing = new Set(
-          path15.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
-        );
-        for (const unit of units) {
-          if (!existing.has(unit)) {
-            path15.parent.init.elements = path15.parent.init.elements.map((element) => {
-              if (t3.isStringLiteral(element)) {
-                return t3.stringLiteral(element.value);
-              }
-              return element;
-            });
-            path15.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 = path8.resolve(rootDir, opts.lengthUnitsFilePath);
-  const exists = fs8.existsSync(dataTypesFilePath);
-  if (!exists) {
-    return { changed: false, code: void 0 };
-  }
-  const content = fs8.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 ? path8.resolve(opts.destPath) : dataTypesFilePath;
-      fs8.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 = path8.resolve(rootDir, "dist");
-  if (!fs8.existsSync(distDir)) {
-    return { files: [], changed: false };
-  }
-  const entries = fs8.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 = path8.join(distDir, chunkName);
-    const code = fs8.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(path15) {
-        for (const unit of opts.units) {
-          if (path15.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
-            item.hasPatched = true;
-            return;
-          }
-          path15.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) {
-      fs8.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(path15) {
-      if (path15.node.name === variableName && t4.isVariableDeclarator(path15.parent) && t4.isArrayExpression(path15.parent.init)) {
-        found = true;
-        const existing = new Set(
-          path15.parent.init.elements.map((element) => t4.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
-        );
-        missingUnits = units.filter((unit) => !existing.has(unit));
-        path15.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 = path9.resolve(packageInfo.rootPath, relative);
-    if (!fs9.existsSync(filePath)) {
-      checks.push({ relative, exists: false, patched: false });
-      return;
-    }
-    const content = fs9.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) => fs9.existsSync(path9.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 = path9.resolve(rootDir, lengthUnitsFilePath);
-  const files = fs9.existsSync(target) ? [path9.relative(rootDir, target)] : [];
-  if (!fs9.existsSync(target)) {
-    return {
-      name: "extendLengthUnits",
-      status: "not-applied",
-      reason: `missing ${lengthUnitsFilePath}`,
-      files
-    };
-  }
-  const content = fs9.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 = path9.resolve(rootDir, "dist");
-  if (!fs9.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) => path9.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) => path9.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/api/tailwindcss-patcher.ts
-import process6 from "process";
-import fs11 from "fs-extra";
-import { getPackageInfoSync } from "local-pkg";
-import path11 from "pathe";
-import { coerce } from "semver";
-
-// src/patching/operations/export-context/index.ts
-import fs10 from "fs-extra";
-import path10 from "pathe";
-function writeFileIfRequired(filePath, code, overwrite, successMessage) {
-  if (!overwrite) {
-    return;
-  }
-  fs10.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 = path10.resolve(rootDir, processFileRelative);
-    if (fs10.existsSync(processFilePath)) {
-      const content = fs10.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) => fs10.existsSync(path10.resolve(rootDir, candidate)));
-    if (pluginRelative) {
-      const pluginPath = path10.resolve(rootDir, pluginRelative);
-      const content = fs10.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 = path10.resolve(rootDir, processFileRelative);
-    if (fs10.existsSync(processFilePath)) {
-      const content = fs10.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 = path10.resolve(rootDir, pluginRelative);
-    if (fs10.existsSync(pluginPath)) {
-      const content = fs10.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/runtime/collector.ts
-function resolveTailwindExecutionOptions(normalized, majorVersion) {
-  const base = normalized.tailwind;
-  if (majorVersion === 2 && base.v2) {
-    return {
-      cwd: base.v2.cwd ?? base.cwd ?? normalized.projectRoot,
-      config: base.v2.config ?? base.config,
-      postcssPlugin: base.v2.postcssPlugin ?? base.postcssPlugin
-    };
-  }
-  if (majorVersion === 3 && base.v3) {
-    return {
-      cwd: base.v3.cwd ?? base.cwd ?? normalized.projectRoot,
-      config: base.v3.config ?? base.config,
-      postcssPlugin: base.v3.postcssPlugin ?? base.postcssPlugin
-    };
-  }
-  return {
-    cwd: base.cwd ?? normalized.projectRoot,
-    config: base.config,
-    postcssPlugin: base.postcssPlugin
-  };
-}
-var BaseCollector = class {
-  constructor(packageInfo, options, majorVersion) {
-    this.packageInfo = packageInfo;
-    this.options = options;
-    this.majorVersion = majorVersion;
-  }
-  async patch() {
-    return applyTailwindPatches({
-      packageInfo: this.packageInfo,
-      options: this.options,
-      majorVersion: this.majorVersion
-    });
-  }
-  async getPatchStatus() {
-    return getPatchStatusReport({
-      packageInfo: this.packageInfo,
-      options: this.options,
-      majorVersion: this.majorVersion
-    });
-  }
-  getContexts() {
-    return loadRuntimeContexts(
-      this.packageInfo,
-      this.majorVersion,
-      this.options.features.exposeContext.refProperty
-    );
-  }
-};
-var RuntimeCollector = class extends BaseCollector {
-  constructor(packageInfo, options, majorVersion, snapshotFactory) {
-    super(packageInfo, options, majorVersion);
-    this.snapshotFactory = snapshotFactory;
-  }
-  inFlightBuild;
-  async collectClassSet() {
-    const contexts = this.getContexts();
-    return collectClassesFromContexts(contexts, this.options.filter);
-  }
-  getPatchSnapshot() {
-    return this.snapshotFactory();
-  }
-  async runTailwindBuildIfNeeded() {
-    if (this.inFlightBuild) {
-      return this.inFlightBuild;
-    }
-    const executionOptions = resolveTailwindExecutionOptions(this.options, this.majorVersion);
-    const buildOptions = {
-      cwd: executionOptions.cwd,
-      majorVersion: this.majorVersion,
-      ...executionOptions.config === void 0 ? {} : { config: executionOptions.config },
-      ...executionOptions.postcssPlugin === void 0 ? {} : { postcssPlugin: executionOptions.postcssPlugin }
-    };
-    this.inFlightBuild = runTailwindBuild(buildOptions).then(() => void 0);
-    try {
-      await this.inFlightBuild;
-    } finally {
-      this.inFlightBuild = void 0;
-    }
-  }
-};
-var TailwindV4Collector = class extends BaseCollector {
-  constructor(packageInfo, options, snapshotFactory) {
-    super(packageInfo, options, 4);
-    this.snapshotFactory = snapshotFactory;
-  }
-  snapshotFactory;
-  async collectClassSet() {
-    return collectClassesFromTailwindV4(this.options);
-  }
-  getPatchSnapshot() {
-    return this.snapshotFactory();
-  }
-};
-
-// src/api/tailwindcss-patcher.ts
-function resolveInstalledMajorVersion(version) {
-  if (!version) {
-    return void 0;
-  }
-  const coerced = coerce(version);
-  if (!coerced) {
-    return void 0;
-  }
-  const major = coerced.major;
-  if (major === 2 || major === 3 || major === 4) {
-    return major;
-  }
-  if (major >= 4) {
-    return 4;
-  }
-  return void 0;
-}
-function validateInstalledVersion(packageVersion, expectedMajor, packageName) {
-  const installedMajor = resolveInstalledMajorVersion(packageVersion);
-  if (installedMajor === void 0) {
-    return;
-  }
-  if (installedMajor !== expectedMajor) {
-    throw new Error(
-      `Configured tailwindcss.version=${expectedMajor}, but resolved package "${packageName}" is version ${packageVersion}. Update the configuration or resolve the correct package.`
-    );
-  }
-}
-function resolveMajorVersionOrThrow(configuredMajor, packageVersion, packageName) {
-  if (configuredMajor !== void 0) {
-    validateInstalledVersion(packageVersion, configuredMajor, packageName);
-    return configuredMajor;
-  }
-  const installedMajor = resolveInstalledMajorVersion(packageVersion);
-  if (installedMajor !== void 0) {
-    return installedMajor;
-  }
-  throw new Error(
-    `Unable to infer Tailwind CSS major version from resolved package "${packageName}" (${packageVersion ?? "unknown"}). Set "tailwindcss.version" to 2, 3, or 4 explicitly.`
-  );
-}
-function createCollector(packageInfo, options, majorVersion, snapshotFactory) {
-  if (majorVersion === 4) {
-    return new TailwindV4Collector(packageInfo, options, snapshotFactory);
-  }
-  return new RuntimeCollector(packageInfo, options, majorVersion, snapshotFactory);
-}
-var TailwindcssPatcher = class {
-  options;
-  packageInfo;
-  majorVersion;
-  cacheContext;
-  cacheStore;
-  collector;
-  patchMemo;
-  constructor(options = {}) {
-    this.options = normalizeOptions(options);
-    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 = resolveMajorVersionOrThrow(
-      this.options.tailwind.versionHint,
-      this.packageInfo.version,
-      this.options.tailwind.packageName
-    );
-    this.cacheContext = createCacheContextDescriptor(
-      this.options,
-      this.packageInfo,
-      this.majorVersion
-    );
-    this.cacheStore = new CacheStore(this.options.cache, this.cacheContext);
-    this.collector = createCollector(
-      this.packageInfo,
-      this.options,
-      this.majorVersion,
-      () => this.createPatchSnapshot()
-    );
-  }
-  async patch() {
-    const snapshot = this.collector.getPatchSnapshot();
-    if (this.patchMemo && this.patchMemo.snapshot === snapshot) {
-      return this.patchMemo.result;
-    }
-    const result = await this.collector.patch();
-    this.patchMemo = {
-      result,
-      snapshot: this.collector.getPatchSnapshot()
-    };
-    return result;
-  }
-  async getPatchStatus() {
-    return this.collector.getPatchStatus();
-  }
-  getContexts() {
-    return this.collector.getContexts();
-  }
-  createPatchSnapshot() {
-    const entries = [];
-    const pushSnapshot = (filePath) => {
-      if (!fs11.pathExistsSync(filePath)) {
-        entries.push(`${filePath}:missing`);
-        return;
-      }
-      const stat = fs11.statSync(filePath);
-      entries.push(`${filePath}:${stat.size}:${Math.trunc(stat.mtimeMs)}`);
-    };
-    if (this.options.features.exposeContext.enabled && (this.majorVersion === 2 || this.majorVersion === 3)) {
-      if (this.majorVersion === 2) {
-        pushSnapshot(path11.resolve(this.packageInfo.rootPath, "lib/jit/processTailwindFeatures.js"));
-        pushSnapshot(path11.resolve(this.packageInfo.rootPath, "lib/jit/index.js"));
-      } else {
-        pushSnapshot(path11.resolve(this.packageInfo.rootPath, "lib/processTailwindFeatures.js"));
-        const pluginPath = ["lib/plugin.js", "lib/index.js"].map((file) => path11.resolve(this.packageInfo.rootPath, file)).find((file) => fs11.pathExistsSync(file));
-        if (pluginPath) {
-          pushSnapshot(pluginPath);
-        }
-      }
-    }
-    if (this.options.features.extendLengthUnits?.enabled) {
-      if (this.majorVersion === 3) {
-        const target = this.options.features.extendLengthUnits.lengthUnitsFilePath ?? "lib/util/dataTypes.js";
-        pushSnapshot(path11.resolve(this.packageInfo.rootPath, target));
-      } else if (this.majorVersion === 4) {
-        const distDir = path11.resolve(this.packageInfo.rootPath, "dist");
-        if (fs11.pathExistsSync(distDir)) {
-          const chunkNames = fs11.readdirSync(distDir).filter((entry) => entry.endsWith(".js") || entry.endsWith(".mjs")).sort();
-          for (const chunkName of chunkNames) {
-            pushSnapshot(path11.join(distDir, chunkName));
-          }
-        } else {
-          entries.push(`${distDir}:missing`);
-        }
-      }
-    }
-    return entries.join("|");
-  }
-  async collectClassSet() {
-    if (this.majorVersion === 4) {
-      return this.collector.collectClassSet();
-    }
-    const contexts = this.getContexts();
-    return collectClassesFromContexts(contexts, this.options.filter);
-  }
-  async runTailwindBuildIfNeeded() {
-    await this.collector.runTailwindBuildIfNeeded?.();
-  }
-  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 = this.areSetsEqual(existing, set) ? void 0 : await this.cacheStore.write(set);
-      if (writeTarget) {
-        logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
-      }
-    } else {
-      if (set.size > 0) {
-        const writeTarget = this.areSetsEqual(existing, set) ? void 0 : await this.cacheStore.write(set);
-        if (writeTarget) {
-          logger_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.areSetsEqual(existing, set) ? void 0 : this.cacheStore.writeSync(set);
-      if (writeTarget) {
-        logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
-      }
-    } else {
-      if (set.size > 0) {
-        const writeTarget = this.areSetsEqual(existing, set) ? void 0 : this.cacheStore.writeSync(set);
-        if (writeTarget) {
-          logger_default.debug(`[cache] stored ${set.size} classes -> ${writeTarget}`);
-        }
-      } else {
-        return existing;
-      }
-    }
-    return set;
-  }
-  areSetsEqual(a, b) {
-    if (a.size !== b.size) {
-      return false;
-    }
-    for (const value of a) {
-      if (!b.has(value)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  async getClassSet() {
-    await this.runTailwindBuildIfNeeded();
-    const set = await this.collectClassSet();
-    return this.mergeWithCache(set);
-  }
-  getClassSetSync() {
-    if (this.majorVersion === 4) {
-      throw new Error("getClassSetSync is not supported for Tailwind CSS v4 projects. Use getClassSet instead.");
-    }
-    const contexts = this.getContexts();
-    const set = collectClassesFromContexts(contexts, this.options.filter);
-    const merged = this.mergeWithCacheSync(set);
-    if (contexts.length === 0 && merged.size === 0) {
-      return 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 = path11.resolve(this.options.output.file);
-    await fs11.ensureDir(path11.dirname(target));
-    if (this.options.output.format === "json") {
-      const spaces = typeof this.options.output.pretty === "number" ? this.options.output.pretty : void 0;
-      await fs11.writeJSON(target, classList, { spaces });
-    } else {
-      await fs11.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/commands/migration-report.ts
-var MIGRATION_REPORT_KIND = "tw-patch-migrate-report";
-var MIGRATION_REPORT_SCHEMA_VERSION = 1;
-function assertMigrationReportCompatibility(report, 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}.`
-    );
-  }
-}
-
-// src/commands/migrate-config.ts
-import path14 from "pathe";
-
-// src/commands/migration-aggregation.ts
-function createMigrationAggregationState() {
-  return {
-    scannedFiles: 0,
-    changedFiles: 0,
-    writtenFiles: 0,
-    backupsWritten: 0,
-    unchangedFiles: 0,
-    missingFiles: 0,
-    entries: []
-  };
-}
-function collectMigrationExecutionResult(state, result) {
-  if (result.missing) {
-    state.missingFiles += 1;
-    return;
-  }
-  state.scannedFiles += 1;
-  state.entries.push(result.entry);
-  if (result.changed) {
-    state.changedFiles += 1;
-    if (result.wrote) {
-      state.writtenFiles += 1;
-    }
-    if (result.backupWritten) {
-      state.backupsWritten += 1;
-    }
-  } else {
-    state.unchangedFiles += 1;
-  }
-}
-function buildMigrationReport(state, context) {
-  const {
-    cwd,
-    dryRun,
-    rollbackOnError,
-    backupDirectory,
-    toolName,
-    toolVersion,
-    generatedAt = (/* @__PURE__ */ new Date()).toISOString()
-  } = context;
-  return {
-    reportKind: MIGRATION_REPORT_KIND,
-    schemaVersion: MIGRATION_REPORT_SCHEMA_VERSION,
-    generatedAt,
-    tool: {
-      name: toolName,
-      version: toolVersion
-    },
-    cwd,
-    dryRun,
-    rollbackOnError,
-    ...backupDirectory ? { backupDirectory } : {},
-    scannedFiles: state.scannedFiles,
-    changedFiles: state.changedFiles,
-    writtenFiles: state.writtenFiles,
-    backupsWritten: state.backupsWritten,
-    unchangedFiles: state.unchangedFiles,
-    missingFiles: state.missingFiles,
-    entries: state.entries
-  };
-}
-
-// src/commands/migration-file-executor.ts
-import fs13 from "fs-extra";
-import path13 from "pathe";
-
-// src/commands/migration-source.ts
-import generate2 from "@babel/generator";
-import { parse as parse2 } from "@babel/parser";
-import * as t5 from "@babel/types";
-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]
-  };
-}
-
-// src/commands/migration-target-files.ts
-import fs12 from "fs-extra";
-import path12 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;
-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(path12.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 fs12.readdir(dir, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const absolutePath = path12.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 = path12.relative(cwd, file);
-  const isExternal = relative.startsWith("..") || path12.isAbsolute(relative);
-  if (isExternal) {
-    const sanitized = file.replace(/[:/\\]+/g, "_");
-    return path12.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 = path12.relative(cwd, file);
-  if (!relative.startsWith("..") && !path12.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;
-  });
-}
-
-// src/commands/migration-file-executor.ts
-async function rollbackWrittenEntries(wroteEntries) {
-  let rollbackCount = 0;
-  for (const written of [...wroteEntries].reverse()) {
-    try {
-      await fs13.writeFile(written.file, written.source, "utf8");
-      written.entry.written = false;
-      written.entry.rolledBack = true;
-      rollbackCount += 1;
-    } catch {
-    }
-  }
-  return rollbackCount;
-}
-async function executeMigrationFile(options) {
-  const {
-    cwd,
-    file,
-    dryRun,
-    rollbackOnError,
-    backupDirectory,
-    wroteEntries
-  } = options;
-  const exists = await fs13.pathExists(file);
-  if (!exists) {
-    return {
-      missing: true,
-      changed: false,
-      wrote: false,
-      backupWritten: false
-    };
-  }
-  const source = await fs13.readFile(file, "utf8");
-  const migrated = migrateConfigSource(source);
-  const entry = {
-    file,
-    changed: migrated.changed,
-    written: false,
-    rolledBack: false,
-    changes: migrated.changes
-  };
-  if (!migrated.changed || dryRun) {
-    return {
-      missing: false,
-      changed: migrated.changed,
-      wrote: false,
-      backupWritten: false,
-      entry
-    };
-  }
-  let backupWritten = false;
-  try {
-    if (backupDirectory) {
-      const backupRelativePath = resolveBackupRelativePath(cwd, file);
-      const backupFile = path13.resolve(backupDirectory, backupRelativePath);
-      await fs13.ensureDir(path13.dirname(backupFile));
-      await fs13.writeFile(backupFile, source, "utf8");
-      entry.backupFile = backupFile;
-      backupWritten = true;
-    }
-    await fs13.writeFile(file, migrated.code, "utf8");
-    entry.written = true;
-    wroteEntries.push({ file, source, entry });
-    return {
-      missing: false,
-      changed: true,
-      wrote: true,
-      backupWritten,
-      entry
-    };
-  } catch (error) {
-    const rollbackCount = rollbackOnError && wroteEntries.length > 0 ? await rollbackWrittenEntries(wroteEntries) : 0;
-    const reason = error instanceof Error ? error.message : String(error);
-    const rollbackHint = rollbackOnError && rollbackCount > 0 ? ` Rolled back ${rollbackCount} previously written file(s).` : "";
-    throw new Error(`Failed to write migrated config "${file}": ${reason}.${rollbackHint}`);
-  }
-}
-async function restoreConfigEntries(entries, dryRun) {
-  let scannedEntries = 0;
-  let restorableEntries = 0;
-  let restoredFiles = 0;
-  let missingBackups = 0;
-  let skippedEntries = 0;
-  const restored = [];
-  for (const entry of entries) {
-    scannedEntries += 1;
-    const targetFile = entry.file ? path13.resolve(entry.file) : void 0;
-    const backupFile = entry.backupFile ? path13.resolve(entry.backupFile) : void 0;
-    if (!targetFile || !backupFile) {
-      skippedEntries += 1;
-      continue;
-    }
-    restorableEntries += 1;
-    const backupExists = await fs13.pathExists(backupFile);
-    if (!backupExists) {
-      missingBackups += 1;
-      continue;
-    }
-    if (!dryRun) {
-      const backupContent = await fs13.readFile(backupFile, "utf8");
-      await fs13.ensureDir(path13.dirname(targetFile));
-      await fs13.writeFile(targetFile, backupContent, "utf8");
-    }
-    restoredFiles += 1;
-    restored.push(targetFile);
-  }
-  return {
-    scannedEntries,
-    restorableEntries,
-    restoredFiles,
-    missingBackups,
-    skippedEntries,
-    restored
-  };
-}
-
-// src/commands/migration-report-loader.ts
-import fs14 from "fs-extra";
-async function loadMigrationReportForRestore(reportFile) {
-  const report = await fs14.readJSON(reportFile);
-  assertMigrationReportCompatibility(report, reportFile);
-  return {
-    ...report.reportKind === void 0 ? {} : { reportKind: report.reportKind },
-    ...report.schemaVersion === void 0 ? {} : { schemaVersion: report.schemaVersion },
-    entries: Array.isArray(report.entries) ? report.entries : []
-  };
-}
-
-// src/commands/migration-target-resolver.ts
-async function resolveMigrationTargetFiles(options) {
-  const {
-    cwd,
-    files,
-    workspace,
-    maxDepth,
-    include,
-    exclude
-  } = options;
-  const resolvedMaxDepth = maxDepth ?? DEFAULT_WORKSPACE_MAX_DEPTH;
-  const discoveredTargetFiles = files && files.length > 0 ? resolveTargetFiles(cwd, files) : workspace ? await collectWorkspaceConfigFiles(cwd, resolvedMaxDepth) : resolveTargetFiles(cwd);
-  return filterTargetFiles(discoveredTargetFiles, cwd, include, exclude);
-}
-
-// src/commands/migrate-config.ts
-async function migrateConfigFiles(options) {
-  const cwd = path14.resolve(options.cwd);
-  const dryRun = options.dryRun ?? false;
-  const rollbackOnError = options.rollbackOnError ?? true;
-  const backupDirectory = options.backupDir ? path14.resolve(cwd, options.backupDir) : void 0;
-  const targetFiles = await resolveMigrationTargetFiles({
-    cwd,
-    files: options.files,
-    workspace: options.workspace,
-    maxDepth: options.maxDepth,
-    include: options.include,
-    exclude: options.exclude
-  });
-  const aggregation = createMigrationAggregationState();
-  const wroteEntries = [];
-  for (const file of targetFiles) {
-    const result = await executeMigrationFile({
-      cwd,
-      file,
-      dryRun,
-      rollbackOnError,
-      wroteEntries,
-      ...backupDirectory ? { backupDirectory } : {}
-    });
-    collectMigrationExecutionResult(aggregation, result);
-  }
-  return buildMigrationReport(aggregation, {
-    cwd,
-    dryRun,
-    rollbackOnError,
-    ...backupDirectory ? { backupDirectory } : {},
-    toolName: pkgName,
-    toolVersion: pkgVersion
-  });
-}
-async function restoreConfigFiles(options) {
-  const cwd = path14.resolve(options.cwd);
-  const dryRun = options.dryRun ?? false;
-  const strict = options.strict ?? false;
-  const reportFile = path14.resolve(cwd, options.reportFile);
-  const report = await loadMigrationReportForRestore(reportFile);
-  const {
-    scannedEntries,
-    restorableEntries,
-    restoredFiles,
-    missingBackups,
-    skippedEntries,
-    restored
-  } = await restoreConfigEntries(report.entries, dryRun);
-  if (strict && missingBackups > 0) {
-    throw new Error(`Restore failed: ${missingBackups} backup file(s) missing in report ${reportFile}.`);
-  }
-  return {
-    cwd,
-    reportFile,
-    ...report.reportKind === void 0 ? {} : { reportKind: report.reportKind },
-    ...report.schemaVersion === void 0 ? {} : { reportSchemaVersion: report.schemaVersion },
-    dryRun,
-    strict,
-    scannedEntries,
-    restorableEntries,
-    restoredFiles,
-    missingBackups,
-    skippedEntries,
-    restored
-  };
-}
-
-// src/commands/types.ts
-var tailwindcssPatchCommands = ["install", "extract", "tokens", "init", "migrate", "restore", "validate", "status"];
-
-// src/commands/validate.ts
-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 isNodeError2(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 (isNodeError2(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;
-  }
-};
-
-export {
-  logger_default,
-  CacheStore,
-  normalizeOptions,
-  loadWorkspaceConfigModule,
-  loadPatchOptionsForWorkspace,
-  extractRawCandidatesWithPositions,
-  extractRawCandidates,
-  extractValidCandidates,
-  extractProjectCandidatesWithPositions,
-  groupTokensByFile,
-  collectClassesFromContexts,
-  collectClassesFromTailwindV4,
-  loadRuntimeContexts,
-  runTailwindBuild,
-  getPatchStatusReport,
-  TailwindcssPatcher,
-  MIGRATION_REPORT_KIND,
-  MIGRATION_REPORT_SCHEMA_VERSION,
-  migrateConfigFiles,
-  restoreConfigFiles,
-  tailwindcssPatchCommands,
-  VALIDATE_EXIT_CODES,
-  VALIDATE_FAILURE_REASONS,
-  classifyValidateError,
-  ValidateCommandError
-};