tailwindcss-patch 8.0.0 → 8.2.0

package/dist/{chunk-Y45IACSP.mjs → chunk-SB2W2SQP.mjs}

@@ -12,6 +12,9 @@ var CacheStore = class {
   async ensureDir() {
     await fs.ensureDir(this.options.dir);
   }
+  ensureDirSync() {
+    fs.ensureDirSync(this.options.dir);
+  }
   async write(data) {
     if (!this.options.enabled) {
       return void 0;
@@ -25,6 +28,19 @@ var CacheStore = class {
       return void 0;
     }
   }
+  writeSync(data) {
+    if (!this.options.enabled) {
+      return void 0;
+    }
+    try {
+      this.ensureDirSync();
+      fs.writeJSONSync(this.options.path, Array.from(data));
+      return this.options.path;
+    } catch (error) {
+      logger_default.error("Unable to persist Tailwind class cache", error);
+      return void 0;
+    }
+  }
   async read() {
     if (!this.options.enabled) {
       return /* @__PURE__ */ new Set();
@@ -48,10 +64,35 @@ var CacheStore = class {
     }
     return /* @__PURE__ */ new Set();
   }
+  readSync() {
+    if (!this.options.enabled) {
+      return /* @__PURE__ */ new Set();
+    }
+    try {
+      const exists = fs.pathExistsSync(this.options.path);
+      if (!exists) {
+        return /* @__PURE__ */ new Set();
+      }
+      const data = fs.readJSONSync(this.options.path);
+      if (Array.isArray(data)) {
+        return new Set(data.filter((item) => typeof item === "string"));
+      }
+    } catch (error) {
+      logger_default.warn("Unable to read Tailwind class cache, removing invalid file.", error);
+      try {
+        fs.removeSync(this.options.path);
+      } catch (cleanupError) {
+        logger_default.error("Failed to clean up invalid cache file", cleanupError);
+      }
+    }
+    return /* @__PURE__ */ new Set();
+  }
 };
 
 // src/extraction/candidate-extractor.ts
+import { promises as fs2 } from "fs";
 import process from "process";
+import path from "pathe";
 async function importNode() {
   return import("@tailwindcss/node");
 }
@@ -99,6 +140,139 @@ async function extractValidCandidates(options) {
   );
   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];
+    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 = path.extname(filename).replace(/^\./, "");
+  return ext || "txt";
+}
+function toRelativeFile(cwd, filename) {
+  const relative = path.relative(cwd, filename);
+  return relative === "" ? path.basename(filename) : relative;
+}
+async function extractProjectCandidatesWithPositions(options) {
+  const cwd = options?.cwd ? path.resolve(options.cwd) : process.cwd();
+  const normalizedSources = normalizeSources(options?.sources, cwd);
+  const { Scanner } = await importOxide();
+  const scanner = new Scanner({
+    sources: normalizedSources
+  });
+  const files = scanner.files ?? [];
+  const entries = [];
+  const skipped = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = await fs2.readFile(file, "utf8");
+    } catch (error) {
+      skipped.push({
+        file,
+        reason: error instanceof Error ? error.message : "Unknown error"
+      });
+      continue;
+    }
+    const extension = toExtension(file);
+    const matches = scanner.getCandidatesWithPositions({
+      file,
+      content,
+      extension
+    });
+    if (!matches.length) {
+      continue;
+    }
+    const offsets = buildLineOffsets(content);
+    const relativeFile = toRelativeFile(cwd, file);
+    for (const match of matches) {
+      const info = resolveLineMeta(content, offsets, match.position);
+      entries.push({
+        rawCandidate: match.candidate,
+        file,
+        relativeFile,
+        extension,
+        start: match.position,
+        end: match.position + match.candidate.length,
+        length: match.candidate.length,
+        line: info.line,
+        column: info.column,
+        lineText: info.lineText
+      });
+    }
+  }
+  return {
+    entries,
+    filesScanned: files.length,
+    skippedFiles: skipped,
+    sources: normalizedSources
+  };
+}
+function groupTokensByFile(report, options) {
+  const key = options?.key ?? "relative";
+  const stripAbsolute = options?.stripAbsolutePaths ?? key !== "absolute";
+  return report.entries.reduce((acc, entry) => {
+    const bucketKey = key === "absolute" ? entry.file : entry.relativeFile;
+    if (!acc[bucketKey]) {
+      acc[bucketKey] = [];
+    }
+    const value = stripAbsolute ? {
+      ...entry,
+      file: entry.relativeFile
+    } : entry;
+    acc[bucketKey].push(value);
+    return acc;
+  }, {});
+}
 
 // src/options/legacy.ts
 function normalizeLegacyFeatures(patch) {
@@ -201,7 +375,7 @@ function fromUnifiedConfig(registry) {
 
 // src/options/normalize.ts
 import process2 from "process";
-import path from "pathe";
+import path2 from "pathe";
 
 // src/constants.ts
 var pkgName = "tailwindcss-patch";
@@ -219,7 +393,7 @@ function toPrettyValue(value) {
 function normalizeCacheOptions(cache, projectRoot) {
   let enabled = false;
   let cwd = projectRoot;
-  let dir = path.resolve(cwd, "node_modules/.cache", pkgName);
+  let dir = path2.resolve(cwd, "node_modules/.cache", pkgName);
   let file = "class-cache.json";
   let strategy = "merge";
   if (typeof cache === "boolean") {
@@ -227,11 +401,11 @@ function normalizeCacheOptions(cache, projectRoot) {
   } else if (typeof cache === "object" && cache) {
     enabled = cache.enabled ?? true;
     cwd = cache.cwd ?? cwd;
-    dir = cache.dir ? path.resolve(cache.dir) : path.resolve(cwd, "node_modules/.cache", pkgName);
+    dir = cache.dir ? path2.resolve(cache.dir) : path2.resolve(cwd, "node_modules/.cache", pkgName);
     file = cache.file ?? file;
     strategy = cache.strategy ?? strategy;
   }
-  const filename = path.resolve(dir, file);
+  const filename = path2.resolve(dir, file);
   return {
     enabled,
     cwd,
@@ -294,8 +468,8 @@ function normalizeExtendLengthUnitsOptions(features) {
   };
 }
 function normalizeTailwindV4Options(v4, fallbackBase) {
-  const base = v4?.base ? path.resolve(v4.base) : fallbackBase;
-  const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => path.resolve(entry)) : [];
+  const base = v4?.base ? path2.resolve(v4.base) : fallbackBase;
+  const cssEntries = Array.isArray(v4?.cssEntries) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => path2.resolve(entry)) : [];
   const sources = v4?.sources?.length ? v4.sources : [
     {
       base,
@@ -331,7 +505,7 @@ function normalizeTailwindOptions(tailwind, projectRoot) {
   };
 }
 function normalizeOptions(options = {}) {
-  const projectRoot = options.cwd ? path.resolve(options.cwd) : process2.cwd();
+  const projectRoot = options.cwd ? path2.resolve(options.cwd) : process2.cwd();
   const overwrite = options.overwrite ?? true;
   const output = normalizeOutputOptions(options.output);
   const cache = normalizeCacheOptions(options.cache, projectRoot);
@@ -363,8 +537,8 @@ function normalizeOptions(options = {}) {
 
 // src/runtime/class-collector.ts
 import process3 from "process";
-import fs2 from "fs-extra";
-import path2 from "pathe";
+import fs3 from "fs-extra";
+import path3 from "pathe";
 
 // src/utils.ts
 function isObject(val) {
@@ -422,11 +596,11 @@ async function collectClassesFromTailwindV4(options) {
   });
   if (v4Options.cssEntries.length > 0) {
     for (const entry of v4Options.cssEntries) {
-      const filePath = path2.isAbsolute(entry) ? entry : path2.resolve(options.projectRoot, entry);
-      if (!await fs2.pathExists(filePath)) {
+      const filePath = path3.isAbsolute(entry) ? entry : path3.resolve(options.projectRoot, entry);
+      if (!await fs3.pathExists(filePath)) {
         continue;
       }
-      const css = await fs2.readFile(filePath, "utf8");
+      const css = await fs3.readFile(filePath, "utf8");
       const candidates = await extractValidCandidates({
         cwd: options.projectRoot,
         base: v4Options.base,
@@ -457,23 +631,23 @@ async function collectClassesFromTailwindV4(options) {
 
 // src/runtime/context-registry.ts
 import { createRequire } from "module";
-import fs3 from "fs-extra";
-import path3 from "pathe";
+import fs4 from "fs-extra";
+import path4 from "pathe";
 var require2 = createRequire(import.meta.url);
 function resolveRuntimeEntry(packageInfo, majorVersion) {
   const root = packageInfo.rootPath;
   if (majorVersion === 2) {
-    const jitIndex = path3.join(root, "lib/jit/index.js");
-    if (fs3.existsSync(jitIndex)) {
+    const jitIndex = path4.join(root, "lib/jit/index.js");
+    if (fs4.existsSync(jitIndex)) {
       return jitIndex;
     }
   } else if (majorVersion === 3) {
-    const plugin = path3.join(root, "lib/plugin.js");
-    const index = path3.join(root, "lib/index.js");
-    if (fs3.existsSync(plugin)) {
+    const plugin = path4.join(root, "lib/plugin.js");
+    const index = path4.join(root, "lib/index.js");
+    if (fs4.existsSync(plugin)) {
       return plugin;
     }
-    if (fs3.existsSync(index)) {
+    if (fs4.existsSync(index)) {
       return index;
     }
   }
@@ -506,12 +680,12 @@ function loadRuntimeContexts(packageInfo, majorVersion, refProperty) {
 
 // src/runtime/process-tailwindcss.ts
 import { createRequire as createRequire2 } from "module";
-import path4 from "pathe";
+import path5 from "pathe";
 import postcss from "postcss";
 import { loadConfig } from "tailwindcss-config";
 var require3 = createRequire2(import.meta.url);
 async function resolveConfigPath(options) {
-  if (options.config && path4.isAbsolute(options.config)) {
+  if (options.config && path5.isAbsolute(options.config)) {
     return options.config;
   }
   const result = await loadConfig({ cwd: options.cwd });
@@ -543,14 +717,14 @@ async function runTailwindBuild(options) {
 
 // src/api/tailwindcss-patcher.ts
 import process4 from "process";
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 import { getPackageInfoSync } from "local-pkg";
-import path7 from "pathe";
+import path8 from "pathe";
 import { coerce } from "semver";
 
 // src/patching/operations/export-context/index.ts
-import fs4 from "fs-extra";
-import path5 from "pathe";
+import fs5 from "fs-extra";
+import path6 from "pathe";
 
 // src/patching/operations/export-context/postcss-v2.ts
 import * as t from "@babel/types";
@@ -589,8 +763,8 @@ function transformProcessTailwindFeaturesReturnContextV2(content) {
   });
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path8) {
-      const node = path8.node;
+    FunctionDeclaration(path9) {
+      const node = path9.node;
       if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
         return;
       }
@@ -621,8 +795,8 @@ function transformPostcssPluginV2(content, options) {
   const ast = parse(content);
   let hasPatched = false;
   traverse(ast, {
-    Program(path8) {
-      const program = path8.node;
+    Program(path9) {
+      const program = path9.node;
       const index = program.body.findIndex((statement) => {
         return t.isFunctionDeclaration(statement) && statement.id?.name === "_default";
       });
@@ -656,11 +830,11 @@ function transformPostcssPluginV2(content, options) {
         );
       }
     },
-    FunctionDeclaration(path8) {
+    FunctionDeclaration(path9) {
       if (hasPatched) {
         return;
       }
-      const fn = path8.node;
+      const fn = path9.node;
       if (fn.id?.name !== "_default") {
         return;
       }
@@ -749,8 +923,8 @@ function transformProcessTailwindFeaturesReturnContext(content) {
   const ast = parse(content);
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path8) {
-      const node = path8.node;
+    FunctionDeclaration(path9) {
+      const node = path9.node;
       if (node.id?.name !== "processTailwindFeatures" || node.body.body.length !== 1) {
         return;
       }
@@ -782,8 +956,8 @@ function transformPostcssPlugin(content, { refProperty }) {
   const valueMember = t2.memberExpression(refIdentifier, t2.identifier("value"));
   let hasPatched = false;
   traverse(ast, {
-    Program(path8) {
-      const program = path8.node;
+    Program(path9) {
+      const program = path9.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";
       });
@@ -821,11 +995,11 @@ function transformPostcssPlugin(content, { refProperty }) {
         );
       }
     },
-    FunctionExpression(path8) {
+    FunctionExpression(path9) {
       if (hasPatched) {
         return;
       }
-      const fn = path8.node;
+      const fn = path9.node;
       if (fn.id?.name !== "tailwindcss" || fn.body.body.length !== 1) {
         return;
       }
@@ -899,7 +1073,7 @@ function writeFileIfRequired(filePath, code, overwrite, successMessage) {
   if (!overwrite) {
     return;
   }
-  fs4.writeFileSync(filePath, code, {
+  fs5.writeFileSync(filePath, code, {
     encoding: "utf8"
   });
   logger_default.success(successMessage);
@@ -912,9 +1086,9 @@ function applyExposeContextPatch(params) {
   };
   if (majorVersion === 3) {
     const processFileRelative = "lib/processTailwindFeatures.js";
-    const processFilePath = path5.resolve(rootDir, processFileRelative);
-    if (fs4.existsSync(processFilePath)) {
-      const content = fs4.readFileSync(processFilePath, "utf8");
+    const processFilePath = path6.resolve(rootDir, processFileRelative);
+    if (fs5.existsSync(processFilePath)) {
+      const content = fs5.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContext(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -928,10 +1102,10 @@ function applyExposeContextPatch(params) {
       }
     }
     const pluginCandidates = ["lib/plugin.js", "lib/index.js"];
-    const pluginRelative = pluginCandidates.find((candidate) => fs4.existsSync(path5.resolve(rootDir, candidate)));
+    const pluginRelative = pluginCandidates.find((candidate) => fs5.existsSync(path6.resolve(rootDir, candidate)));
     if (pluginRelative) {
-      const pluginPath = path5.resolve(rootDir, pluginRelative);
-      const content = fs4.readFileSync(pluginPath, "utf8");
+      const pluginPath = path6.resolve(rootDir, pluginRelative);
+      const content = fs5.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPlugin(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -946,9 +1120,9 @@ function applyExposeContextPatch(params) {
     }
   } else if (majorVersion === 2) {
     const processFileRelative = "lib/jit/processTailwindFeatures.js";
-    const processFilePath = path5.resolve(rootDir, processFileRelative);
-    if (fs4.existsSync(processFilePath)) {
-      const content = fs4.readFileSync(processFilePath, "utf8");
+    const processFilePath = path6.resolve(rootDir, processFileRelative);
+    if (fs5.existsSync(processFilePath)) {
+      const content = fs5.readFileSync(processFilePath, "utf8");
       const { code, hasPatched } = transformProcessTailwindFeaturesReturnContextV2(content);
       result.files[processFileRelative] = code;
       if (!hasPatched) {
@@ -962,9 +1136,9 @@ function applyExposeContextPatch(params) {
       }
     }
     const pluginRelative = "lib/jit/index.js";
-    const pluginPath = path5.resolve(rootDir, pluginRelative);
-    if (fs4.existsSync(pluginPath)) {
-      const content = fs4.readFileSync(pluginPath, "utf8");
+    const pluginPath = path6.resolve(rootDir, pluginRelative);
+    if (fs5.existsSync(pluginPath)) {
+      const content = fs5.readFileSync(pluginPath, "utf8");
       const { code, hasPatched } = transformPostcssPluginV2(content, { refProperty });
       result.files[pluginRelative] = code;
       if (!hasPatched) {
@@ -983,29 +1157,29 @@ function applyExposeContextPatch(params) {
 
 // src/patching/operations/extend-length-units.ts
 import * as t3 from "@babel/types";
-import fs5 from "fs-extra";
-import path6 from "pathe";
+import fs6 from "fs-extra";
+import path7 from "pathe";
 function updateLengthUnitsArray(content, options) {
   const { variableName = "lengthUnits", units } = options;
   const ast = parse(content);
   let arrayRef;
   let changed = false;
   traverse(ast, {
-    Identifier(path8) {
-      if (path8.node.name === variableName && t3.isVariableDeclarator(path8.parent) && t3.isArrayExpression(path8.parent.init)) {
-        arrayRef = path8.parent.init;
+    Identifier(path9) {
+      if (path9.node.name === variableName && t3.isVariableDeclarator(path9.parent) && t3.isArrayExpression(path9.parent.init)) {
+        arrayRef = path9.parent.init;
         const existing = new Set(
-          path8.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
+          path9.parent.init.elements.map((element) => t3.isStringLiteral(element) ? element.value : void 0).filter(Boolean)
         );
         for (const unit of units) {
           if (!existing.has(unit)) {
-            path8.parent.init.elements = path8.parent.init.elements.map((element) => {
+            path9.parent.init.elements = path9.parent.init.elements.map((element) => {
               if (t3.isStringLiteral(element)) {
                 return t3.stringLiteral(element.value);
               }
               return element;
             });
-            path8.parent.init.elements.push(t3.stringLiteral(unit));
+            path9.parent.init.elements.push(t3.stringLiteral(unit));
             changed = true;
           }
         }
@@ -1026,12 +1200,12 @@ function applyExtendLengthUnitsPatchV3(rootDir, options) {
     lengthUnitsFilePath: options.lengthUnitsFilePath ?? "lib/util/dataTypes.js",
     variableName: options.variableName ?? "lengthUnits"
   };
-  const dataTypesFilePath = path6.resolve(rootDir, opts.lengthUnitsFilePath);
-  const exists = fs5.existsSync(dataTypesFilePath);
+  const dataTypesFilePath = path7.resolve(rootDir, opts.lengthUnitsFilePath);
+  const exists = fs6.existsSync(dataTypesFilePath);
   if (!exists) {
     return { changed: false, code: void 0 };
   }
-  const content = fs5.readFileSync(dataTypesFilePath, "utf8");
+  const content = fs6.readFileSync(dataTypesFilePath, "utf8");
   const { arrayRef, changed } = updateLengthUnitsArray(content, opts);
   if (!arrayRef || !changed) {
     return { changed: false, code: void 0 };
@@ -1042,8 +1216,8 @@ function applyExtendLengthUnitsPatchV3(rootDir, options) {
   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 ? path6.resolve(opts.destPath) : dataTypesFilePath;
-      fs5.writeFileSync(target, nextCode, "utf8");
+      const target = opts.destPath ? path7.resolve(opts.destPath) : dataTypesFilePath;
+      fs6.writeFileSync(target, nextCode, "utf8");
       logger_default.success("Patched Tailwind CSS length unit list (v3).");
     }
     return {
@@ -1061,16 +1235,16 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
     return { files: [], changed: false };
   }
   const opts = { ...options };
-  const distDir = path6.resolve(rootDir, "dist");
-  if (!fs5.existsSync(distDir)) {
+  const distDir = path7.resolve(rootDir, "dist");
+  if (!fs6.existsSync(distDir)) {
     return { files: [], changed: false };
   }
-  const entries = fs5.readdirSync(distDir);
+  const entries = fs6.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 = path6.join(distDir, chunkName);
-    const code = fs5.readFileSync(file, "utf8");
+    const file = path7.join(distDir, chunkName);
+    const code = fs6.readFileSync(file, "utf8");
     const match = pattern.exec(code);
     if (!match) {
       return null;
@@ -1086,13 +1260,13 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
     const { code, file, match } = item;
     const ast = parse(match[0], { sourceType: "unambiguous" });
     traverse(ast, {
-      ArrayExpression(path8) {
+      ArrayExpression(path9) {
         for (const unit of opts.units) {
-          if (path8.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
+          if (path9.node.elements.some((element) => t3.isStringLiteral(element) && element.value === unit)) {
             item.hasPatched = true;
             return;
           }
-          path8.node.elements.push(t3.stringLiteral(unit));
+          path9.node.elements.push(t3.stringLiteral(unit));
         }
       }
     });
@@ -1110,7 +1284,7 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
       }
     ]);
     if (opts.overwrite) {
-      fs5.writeFileSync(file, item.code, "utf8");
+      fs6.writeFileSync(file, item.code, "utf8");
     }
   }
   if (candidates.some((file) => !file.hasPatched)) {
@@ -1245,6 +1419,13 @@ var TailwindcssPatcher = class {
     const contexts = this.getContexts();
     return collectClassesFromContexts(contexts, this.options.filter);
   }
+  collectClassSetSync() {
+    if (this.majorVersion === 4) {
+      throw new Error("getClassSetSync is not supported for Tailwind CSS v4 projects. Use getClassSet instead.");
+    }
+    const contexts = this.getContexts();
+    return collectClassesFromContexts(contexts, this.options.filter);
+  }
   async mergeWithCache(set) {
     if (!this.options.cache.enabled) {
       return set;
@@ -1264,11 +1445,34 @@ var TailwindcssPatcher = class {
     }
     return set;
   }
+  mergeWithCacheSync(set) {
+    if (!this.options.cache.enabled) {
+      return set;
+    }
+    const existing = this.cacheStore.readSync();
+    if (this.options.cache.strategy === "merge") {
+      for (const value of existing) {
+        set.add(value);
+      }
+      this.cacheStore.writeSync(set);
+    } else {
+      if (set.size > 0) {
+        this.cacheStore.writeSync(set);
+      } else {
+        return existing;
+      }
+    }
+    return set;
+  }
   async getClassSet() {
     await this.runTailwindBuildIfNeeded();
     const set = await this.collectClassSet();
     return this.mergeWithCache(set);
   }
+  getClassSetSync() {
+    const set = this.collectClassSetSync();
+    return this.mergeWithCacheSync(set);
+  }
   async extract(options) {
     const shouldWrite = options?.write ?? this.options.output.enabled;
     const classSet = await this.getClassSet();
@@ -1280,13 +1484,13 @@ var TailwindcssPatcher = class {
     if (!shouldWrite || !this.options.output.file) {
       return result;
     }
-    const target = path7.resolve(this.options.output.file);
-    await fs6.ensureDir(path7.dirname(target));
+    const target = path8.resolve(this.options.output.file);
+    await fs7.ensureDir(path8.dirname(target));
     if (this.options.output.format === "json") {
       const spaces = typeof this.options.output.pretty === "number" ? this.options.output.pretty : void 0;
-      await fs6.writeJSON(target, classList, { spaces });
+      await fs7.writeJSON(target, classList, { spaces });
     } else {
-      await fs6.writeFile(target, `${classList.join("\n")}
+      await fs7.writeFile(target, `${classList.join("\n")}
 `, "utf8");
     }
     logger_default.success(`Tailwind CSS class list saved to ${target.replace(process4.cwd(), ".")}`);
@@ -1297,6 +1501,22 @@ var TailwindcssPatcher = class {
   }
   // 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 report = await this.collectContentTokens({
+      cwd: options?.cwd,
+      sources: options?.sources
+    });
+    return groupTokensByFile(report, {
+      key: options?.key,
+      stripAbsolutePaths: options?.stripAbsolutePaths
+    });
+  }
 };
 
 export {
@@ -1305,6 +1525,8 @@ export {
   extractRawCandidatesWithPositions,
   extractRawCandidates,
   extractValidCandidates,
+  extractProjectCandidatesWithPositions,
+  groupTokensByFile,
   fromLegacyOptions,
   fromUnifiedConfig,
   normalizeOptions,