tailwindcss-patch 8.0.0 → 8.2.0

package/README.md

@@ -34,6 +34,9 @@ pnpm dlx tw-patch install
 
 # Extract all classes into the configured output file
 pnpm dlx tw-patch extract
+
+# Capture every token (candidate) with file/position metadata
+pnpm dlx tw-patch tokens --format lines
 ```
 
 ### Extract options
@@ -48,6 +51,16 @@ pnpm dlx tw-patch extract
 
 The CLI loads `tailwindcss-patch.config.ts` via `@tailwindcss-mangle/config`. Legacy configs continue to work; see the [migration guide](./MIGRATION.md) for hints on the new fields.
 
+### Token report options
+
+| Flag                     | Description                                                                 |
+| ------------------------ | --------------------------------------------------------------------------- |
+| `--cwd <dir>`            | Use a different working directory when loading configuration.               |
+| `--output <file>`        | Override the token report target file (defaults to `.tw-patch/tw-token-report.json`). |
+| `--format <json\|lines\|grouped-json>` | Choose between a JSON payload (default), newline summaries, or JSON grouped by file path. |
+| `--group-key <relative\|absolute>` | Control grouped-json keys (defaults to relative paths). |
+| `--no-write`             | Skip writing to disk and only print a preview.                              |
+
 ## Programmatic API
 
 ```ts
@@ -81,6 +94,12 @@ const patcher = new TailwindcssPatcher({
 
 await patcher.patch()
 const { classList, filename } = await patcher.extract()
+const tokenReport = await patcher.collectContentTokens()
+console.log(tokenReport.entries[0]) // { rawCandidate, file, line, column, ... }
+const groupedTokens = await patcher.collectContentTokensByFile()
+console.log(groupedTokens['src/button.tsx'][0].rawCandidate)
+// Preserve absolute file paths:
+// await patcher.collectContentTokensByFile({ key: 'absolute', stripAbsolutePaths: false })
 ```
 
 The constructor accepts either the new object shown above or the historical `patch`/`cache` shape. Conversions happen internally so existing configs remain backwards compatible.
@@ -89,6 +108,8 @@ The constructor accepts either the new object shown above or the historical `pat
 
 - `normalizeOptions` – normalise raw user input to the runtime shape.
 - `CacheStore` – read/write class caches respecting merge or overwrite semantics.
+- `extractProjectCandidatesWithPositions` – gather Tailwind tokens for every configured source file with location metadata.
+- `groupTokensByFile` – convert a token report into a `{ [filePath]: TailwindTokenLocation[] }` map.
 - `extractValidCandidates` – scan Tailwind v4 CSS/content sources with the Tailwind Oxide scanner.
 - `runTailwindBuild` – run the Tailwind PostCSS plugin for v2/v3 projects to prime runtime contexts.
 

package/dist/{chunk-FSTUQMKT.js → chunk-5KFYHNFJ.js}

@@ -16,6 +16,9 @@ var CacheStore = class {
   async ensureDir() {
     await _fsextra2.default.ensureDir(this.options.dir);
   }
+  ensureDirSync() {
+    _fsextra2.default.ensureDirSync(this.options.dir);
+  }
   async write(data) {
     if (!this.options.enabled) {
       return void 0;
@@ -29,6 +32,19 @@ var CacheStore = class {
       return void 0;
     }
   }
+  writeSync(data) {
+    if (!this.options.enabled) {
+      return void 0;
+    }
+    try {
+      this.ensureDirSync();
+      _fsextra2.default.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();
@@ -52,10 +68,35 @@ var CacheStore = class {
     }
     return /* @__PURE__ */ new Set();
   }
+  readSync() {
+    if (!this.options.enabled) {
+      return /* @__PURE__ */ new Set();
+    }
+    try {
+      const exists = _fsextra2.default.pathExistsSync(this.options.path);
+      if (!exists) {
+        return /* @__PURE__ */ new Set();
+      }
+      const data = _fsextra2.default.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 {
+        _fsextra2.default.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
+var _fs = require('fs');
 var _process = require('process'); var _process2 = _interopRequireDefault(_process);
+var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_pathe);
 async function importNode() {
   return Promise.resolve().then(() => _interopRequireWildcard(require("@tailwindcss/node")));
 }
@@ -103,11 +144,144 @@ async function extractValidCandidates(options) {
   );
   return validCandidates;
 }
+function normalizeSources(sources, cwd) {
+  const baseSources = _optionalChain([sources, 'optionalAccess', _ => _.length]) ? sources : [
+    {
+      base: cwd,
+      pattern: "**/*",
+      negated: false
+    }
+  ];
+  return baseSources.map((source) => ({
+    base: _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(offsets[offsets.length - 2], () => ( 0));
+  return {
+    line: offsets.length - 1,
+    column: index - lastStart + 1,
+    lineText: content.slice(lastStart)
+  };
+}
+function toExtension(filename) {
+  const ext = _pathe2.default.extname(filename).replace(/^\./, "");
+  return ext || "txt";
+}
+function toRelativeFile(cwd, filename) {
+  const relative = _pathe2.default.relative(cwd, filename);
+  return relative === "" ? _pathe2.default.basename(filename) : relative;
+}
+async function extractProjectCandidatesWithPositions(options) {
+  const cwd = _optionalChain([options, 'optionalAccess', _2 => _2.cwd]) ? _pathe2.default.resolve(options.cwd) : _process2.default.cwd();
+  const normalizedSources = normalizeSources(_optionalChain([options, 'optionalAccess', _3 => _3.sources]), cwd);
+  const { Scanner } = await importOxide();
+  const scanner = new Scanner({
+    sources: normalizedSources
+  });
+  const files = _nullishCoalesce(scanner.files, () => ( []));
+  const entries = [];
+  const skipped = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = await _fs.promises.readFile(file, "utf8");
+    } catch (error) {
+      skipped.push({
+        file,
+        reason: error instanceof Error ? error.message : "Unknown error"
+      });
+      continue;
+    }
+    const extension = toExtension(file);
+    const matches = scanner.getCandidatesWithPositions({
+      file,
+      content,
+      extension
+    });
+    if (!matches.length) {
+      continue;
+    }
+    const offsets = buildLineOffsets(content);
+    const relativeFile = toRelativeFile(cwd, file);
+    for (const match of matches) {
+      const info = resolveLineMeta(content, offsets, match.position);
+      entries.push({
+        rawCandidate: match.candidate,
+        file,
+        relativeFile,
+        extension,
+        start: match.position,
+        end: match.position + match.candidate.length,
+        length: match.candidate.length,
+        line: info.line,
+        column: info.column,
+        lineText: info.lineText
+      });
+    }
+  }
+  return {
+    entries,
+    filesScanned: files.length,
+    skippedFiles: skipped,
+    sources: normalizedSources
+  };
+}
+function groupTokensByFile(report, options) {
+  const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _4 => _4.key]), () => ( "relative"));
+  const stripAbsolute = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.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) {
-  const apply = _optionalChain([patch, 'optionalAccess', _ => _.applyPatches]);
-  const extend = _optionalChain([apply, 'optionalAccess', _2 => _2.extendLengthUnits]);
+  const apply = _optionalChain([patch, 'optionalAccess', _6 => _6.applyPatches]);
+  const extend = _optionalChain([apply, 'optionalAccess', _7 => _7.extendLengthUnits]);
   let extendOption = false;
   if (extend && typeof extend === "object") {
     extendOption = {
@@ -118,11 +292,11 @@ function normalizeLegacyFeatures(patch) {
     extendOption = {
       enabled: true,
       units: ["rpx"],
-      overwrite: _optionalChain([patch, 'optionalAccess', _3 => _3.overwrite])
+      overwrite: _optionalChain([patch, 'optionalAccess', _8 => _8.overwrite])
     };
   }
   return {
-    exposeContext: _nullishCoalesce(_optionalChain([apply, 'optionalAccess', _4 => _4.exportContext]), () => ( true)),
+    exposeContext: _nullishCoalesce(_optionalChain([apply, 'optionalAccess', _9 => _9.exportContext]), () => ( true)),
     extendLengthUnits: extendOption
   };
 }
@@ -132,18 +306,18 @@ function fromLegacyOptions(options) {
   }
   const patch = options.patch;
   const features = normalizeLegacyFeatures(patch);
-  const output = _optionalChain([patch, 'optionalAccess', _5 => _5.output]);
-  const tailwindConfig = _optionalChain([patch, 'optionalAccess', _6 => _6.tailwindcss]);
-  const tailwindVersion = _optionalChain([tailwindConfig, 'optionalAccess', _7 => _7.version]);
-  const tailwindV2 = _optionalChain([tailwindConfig, 'optionalAccess', _8 => _8.v2]);
-  const tailwindV3 = _optionalChain([tailwindConfig, 'optionalAccess', _9 => _9.v3]);
-  const tailwindV4 = _optionalChain([tailwindConfig, 'optionalAccess', _10 => _10.v4]);
-  const tailwindConfigPath = _nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _11 => _11.config]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _12 => _12.config])));
-  const tailwindCwd = _nullishCoalesce(_nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _13 => _13.cwd]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _14 => _14.cwd]))), () => ( _optionalChain([patch, 'optionalAccess', _15 => _15.cwd])));
+  const output = _optionalChain([patch, 'optionalAccess', _10 => _10.output]);
+  const tailwindConfig = _optionalChain([patch, 'optionalAccess', _11 => _11.tailwindcss]);
+  const tailwindVersion = _optionalChain([tailwindConfig, 'optionalAccess', _12 => _12.version]);
+  const tailwindV2 = _optionalChain([tailwindConfig, 'optionalAccess', _13 => _13.v2]);
+  const tailwindV3 = _optionalChain([tailwindConfig, 'optionalAccess', _14 => _14.v3]);
+  const tailwindV4 = _optionalChain([tailwindConfig, 'optionalAccess', _15 => _15.v4]);
+  const tailwindConfigPath = _nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _16 => _16.config]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _17 => _17.config])));
+  const tailwindCwd = _nullishCoalesce(_nullishCoalesce(_optionalChain([tailwindV3, 'optionalAccess', _18 => _18.cwd]), () => ( _optionalChain([tailwindV2, 'optionalAccess', _19 => _19.cwd]))), () => ( _optionalChain([patch, 'optionalAccess', _20 => _20.cwd])));
   return {
-    cwd: _optionalChain([patch, 'optionalAccess', _16 => _16.cwd]),
-    overwrite: _optionalChain([patch, 'optionalAccess', _17 => _17.overwrite]),
-    filter: _optionalChain([patch, 'optionalAccess', _18 => _18.filter]),
+    cwd: _optionalChain([patch, 'optionalAccess', _21 => _21.cwd]),
+    overwrite: _optionalChain([patch, 'optionalAccess', _22 => _22.overwrite]),
+    filter: _optionalChain([patch, 'optionalAccess', _23 => _23.filter]),
     cache: typeof options.cache === "boolean" ? options.cache : options.cache ? {
       ...options.cache,
       enabled: _nullishCoalesce(options.cache.enabled, () => ( true))
@@ -154,9 +328,9 @@ function fromLegacyOptions(options) {
       removeUniversalSelector: output.removeUniversalSelector
     } : void 0,
     tailwind: {
-      packageName: _optionalChain([patch, 'optionalAccess', _19 => _19.packageName]),
+      packageName: _optionalChain([patch, 'optionalAccess', _24 => _24.packageName]),
       version: tailwindVersion,
-      resolve: _optionalChain([patch, 'optionalAccess', _20 => _20.resolve]),
+      resolve: _optionalChain([patch, 'optionalAccess', _25 => _25.resolve]),
       config: tailwindConfigPath,
       cwd: tailwindCwd,
       v2: tailwindV2,
@@ -176,7 +350,7 @@ function fromUnifiedConfig(registry) {
   const tailwind = registry.tailwind;
   const output = registry.output;
   const pretty = (() => {
-    if (_optionalChain([output, 'optionalAccess', _21 => _21.pretty]) === void 0) {
+    if (_optionalChain([output, 'optionalAccess', _26 => _26.pretty]) === void 0) {
       return void 0;
     }
     if (typeof output.pretty === "boolean") {
@@ -205,7 +379,7 @@ function fromUnifiedConfig(registry) {
 
 // src/options/normalize.ts
 
-var _pathe = require('pathe'); var _pathe2 = _interopRequireDefault(_pathe);
+
 
 // src/constants.ts
 var pkgName = "tailwindcss-patch";
@@ -246,11 +420,11 @@ function normalizeCacheOptions(cache, projectRoot) {
   };
 }
 function normalizeOutputOptions(output) {
-  const enabled = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _22 => _22.enabled]), () => ( true));
-  const file = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _23 => _23.file]), () => ( ".tw-patch/tw-class-list.json"));
-  const format = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _24 => _24.format]), () => ( "json"));
-  const pretty = toPrettyValue(_nullishCoalesce(_optionalChain([output, 'optionalAccess', _25 => _25.pretty]), () => ( true)));
-  const removeUniversalSelector = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _26 => _26.removeUniversalSelector]), () => ( true));
+  const enabled = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _27 => _27.enabled]), () => ( true));
+  const file = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _28 => _28.file]), () => ( ".tw-patch/tw-class-list.json"));
+  const format = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _29 => _29.format]), () => ( "json"));
+  const pretty = toPrettyValue(_nullishCoalesce(_optionalChain([output, 'optionalAccess', _30 => _30.pretty]), () => ( true)));
+  const removeUniversalSelector = _nullishCoalesce(_optionalChain([output, 'optionalAccess', _31 => _31.removeUniversalSelector]), () => ( true));
   return {
     enabled,
     file,
@@ -260,13 +434,13 @@ function normalizeOutputOptions(output) {
   };
 }
 function normalizeExposeContextOptions(features) {
-  if (_optionalChain([features, 'optionalAccess', _27 => _27.exposeContext]) === false) {
+  if (_optionalChain([features, 'optionalAccess', _32 => _32.exposeContext]) === false) {
     return {
       enabled: false,
       refProperty: "contextRef"
     };
   }
-  if (typeof _optionalChain([features, 'optionalAccess', _28 => _28.exposeContext]) === "object" && features.exposeContext) {
+  if (typeof _optionalChain([features, 'optionalAccess', _33 => _33.exposeContext]) === "object" && features.exposeContext) {
     return {
       enabled: true,
       refProperty: _nullishCoalesce(features.exposeContext.refProperty, () => ( "contextRef"))
@@ -278,7 +452,7 @@ function normalizeExposeContextOptions(features) {
   };
 }
 function normalizeExtendLengthUnitsOptions(features) {
-  const extend = _optionalChain([features, 'optionalAccess', _29 => _29.extendLengthUnits]);
+  const extend = _optionalChain([features, 'optionalAccess', _34 => _34.extendLengthUnits]);
   if (extend === false || extend === void 0) {
     return null;
   }
@@ -298,9 +472,9 @@ function normalizeExtendLengthUnitsOptions(features) {
   };
 }
 function normalizeTailwindV4Options(v4, fallbackBase) {
-  const base = _optionalChain([v4, 'optionalAccess', _30 => _30.base]) ? _pathe2.default.resolve(v4.base) : fallbackBase;
-  const cssEntries = Array.isArray(_optionalChain([v4, 'optionalAccess', _31 => _31.cssEntries])) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => _pathe2.default.resolve(entry)) : [];
-  const sources = _optionalChain([v4, 'optionalAccess', _32 => _32.sources, 'optionalAccess', _33 => _33.length]) ? v4.sources : [
+  const base = _optionalChain([v4, 'optionalAccess', _35 => _35.base]) ? _pathe2.default.resolve(v4.base) : fallbackBase;
+  const cssEntries = Array.isArray(_optionalChain([v4, 'optionalAccess', _36 => _36.cssEntries])) ? v4.cssEntries.filter((entry) => Boolean(entry)).map((entry) => _pathe2.default.resolve(entry)) : [];
+  const sources = _optionalChain([v4, 'optionalAccess', _37 => _37.sources, 'optionalAccess', _38 => _38.length]) ? v4.sources : [
     {
       base,
       pattern: "**/*",
@@ -309,19 +483,19 @@ function normalizeTailwindV4Options(v4, fallbackBase) {
   ];
   return {
     base,
-    css: _optionalChain([v4, 'optionalAccess', _34 => _34.css]),
+    css: _optionalChain([v4, 'optionalAccess', _39 => _39.css]),
     cssEntries,
     sources
   };
 }
 function normalizeTailwindOptions(tailwind, projectRoot) {
-  const packageName = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _35 => _35.packageName]), () => ( "tailwindcss"));
-  const versionHint = _optionalChain([tailwind, 'optionalAccess', _36 => _36.version]);
-  const resolve = _optionalChain([tailwind, 'optionalAccess', _37 => _37.resolve]);
-  const cwd = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _38 => _38.cwd]), () => ( projectRoot));
-  const config = _optionalChain([tailwind, 'optionalAccess', _39 => _39.config]);
-  const postcssPlugin = _optionalChain([tailwind, 'optionalAccess', _40 => _40.postcssPlugin]);
-  const v4 = normalizeTailwindV4Options(_optionalChain([tailwind, 'optionalAccess', _41 => _41.v4]), cwd);
+  const packageName = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _40 => _40.packageName]), () => ( "tailwindcss"));
+  const versionHint = _optionalChain([tailwind, 'optionalAccess', _41 => _41.version]);
+  const resolve = _optionalChain([tailwind, 'optionalAccess', _42 => _42.resolve]);
+  const cwd = _nullishCoalesce(_optionalChain([tailwind, 'optionalAccess', _43 => _43.cwd]), () => ( projectRoot));
+  const config = _optionalChain([tailwind, 'optionalAccess', _44 => _44.config]);
+  const postcssPlugin = _optionalChain([tailwind, 'optionalAccess', _45 => _45.postcssPlugin]);
+  const v4 = normalizeTailwindV4Options(_optionalChain([tailwind, 'optionalAccess', _46 => _46.v4]), cwd);
   return {
     packageName,
     versionHint,
@@ -329,8 +503,8 @@ function normalizeTailwindOptions(tailwind, projectRoot) {
     cwd,
     config,
     postcssPlugin,
-    v2: _optionalChain([tailwind, 'optionalAccess', _42 => _42.v2]),
-    v3: _optionalChain([tailwind, 'optionalAccess', _43 => _43.v3]),
+    v2: _optionalChain([tailwind, 'optionalAccess', _47 => _47.v2]),
+    v3: _optionalChain([tailwind, 'optionalAccess', _48 => _48.v3]),
     v4
   };
 }
@@ -417,7 +591,7 @@ async function collectClassesFromTailwindV4(options) {
   if (!v4Options) {
     return set;
   }
-  const sources = _optionalChain([v4Options, 'access', _44 => _44.sources, 'optionalAccess', _45 => _45.map, 'call', _46 => _46((source) => {
+  const sources = _optionalChain([v4Options, 'access', _49 => _49.sources, 'optionalAccess', _50 => _50.map, 'call', _51 => _51((source) => {
     return {
       base: _nullishCoalesce(_nullishCoalesce(source.base, () => ( v4Options.base)), () => ( _process2.default.cwd())),
       pattern: source.pattern,
@@ -593,9 +767,9 @@ function transformProcessTailwindFeaturesReturnContextV2(content) {
   });
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path8) {
-      const node = path8.node;
-      if (_optionalChain([node, 'access', _47 => _47.id, 'optionalAccess', _48 => _48.name]) !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
+    FunctionDeclaration(path9) {
+      const node = path9.node;
+      if (_optionalChain([node, 'access', _52 => _52.id, 'optionalAccess', _53 => _53.name]) !== "processTailwindFeatures" || node.body.body.length !== 1 || !t.isReturnStatement(node.body.body[0])) {
         return;
       }
       const returnStatement3 = node.body.body[0];
@@ -625,10 +799,10 @@ function transformPostcssPluginV2(content, options) {
   const ast = _parser.parse.call(void 0, 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) && _optionalChain([statement, 'access', _49 => _49.id, 'optionalAccess', _50 => _50.name]) === "_default";
+        return t.isFunctionDeclaration(statement) && _optionalChain([statement, 'access', _54 => _54.id, 'optionalAccess', _55 => _55.name]) === "_default";
       });
       if (index === -1) {
         return;
@@ -660,12 +834,12 @@ function transformPostcssPluginV2(content, options) {
         );
       }
     },
-    FunctionDeclaration(path8) {
+    FunctionDeclaration(path9) {
       if (hasPatched) {
         return;
       }
-      const fn = path8.node;
-      if (_optionalChain([fn, 'access', _51 => _51.id, 'optionalAccess', _52 => _52.name]) !== "_default") {
+      const fn = path9.node;
+      if (_optionalChain([fn, 'access', _56 => _56.id, 'optionalAccess', _57 => _57.name]) !== "_default") {
         return;
       }
       if (fn.body.body.length !== 1 || !t.isReturnStatement(fn.body.body[0])) {
@@ -753,9 +927,9 @@ function transformProcessTailwindFeaturesReturnContext(content) {
   const ast = _parser.parse.call(void 0, content);
   let hasPatched = false;
   traverse(ast, {
-    FunctionDeclaration(path8) {
-      const node = path8.node;
-      if (_optionalChain([node, 'access', _53 => _53.id, 'optionalAccess', _54 => _54.name]) !== "processTailwindFeatures" || node.body.body.length !== 1) {
+    FunctionDeclaration(path9) {
+      const node = path9.node;
+      if (_optionalChain([node, 'access', _58 => _58.id, 'optionalAccess', _59 => _59.name]) !== "processTailwindFeatures" || node.body.body.length !== 1) {
         return;
       }
       const [returnStatement3] = node.body.body;
@@ -786,10 +960,10 @@ 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) && _optionalChain([statement, 'access', _55 => _55.expression, 'access', _56 => _56.right, 'access', _57 => _57.id, 'optionalAccess', _58 => _58.name]) === "tailwindcss";
+        return t2.isExpressionStatement(statement) && t2.isAssignmentExpression(statement.expression) && t2.isMemberExpression(statement.expression.left) && t2.isFunctionExpression(statement.expression.right) && _optionalChain([statement, 'access', _60 => _60.expression, 'access', _61 => _61.right, 'access', _62 => _62.id, 'optionalAccess', _63 => _63.name]) === "tailwindcss";
       });
       if (index === -1) {
         return;
@@ -825,12 +999,12 @@ function transformPostcssPlugin(content, { refProperty }) {
         );
       }
     },
-    FunctionExpression(path8) {
+    FunctionExpression(path9) {
       if (hasPatched) {
         return;
       }
-      const fn = path8.node;
-      if (_optionalChain([fn, 'access', _59 => _59.id, 'optionalAccess', _60 => _60.name]) !== "tailwindcss" || fn.body.body.length !== 1) {
+      const fn = path9.node;
+      if (_optionalChain([fn, 'access', _64 => _64.id, 'optionalAccess', _65 => _65.name]) !== "tailwindcss" || fn.body.body.length !== 1) {
         return;
       }
       const [returnStatement3] = fn.body.body;
@@ -995,21 +1169,21 @@ function updateLengthUnitsArray(content, options) {
   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;
           }
         }
@@ -1090,13 +1264,13 @@ function applyExtendLengthUnitsPatchV4(rootDir, options) {
     const { code, file, match } = item;
     const ast = _parser.parse.call(void 0, 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));
         }
       }
     });
@@ -1138,7 +1312,7 @@ function applyTailwindPatches(context) {
       majorVersion
     });
   }
-  if (_optionalChain([options, 'access', _61 => _61.features, 'access', _62 => _62.extendLengthUnits, 'optionalAccess', _63 => _63.enabled])) {
+  if (_optionalChain([options, 'access', _66 => _66.features, 'access', _67 => _67.extendLengthUnits, 'optionalAccess', _68 => _68.enabled])) {
     if (majorVersion === 3) {
       results.extendLengthUnits = applyExtendLengthUnitsPatchV3(
         packageInfo.rootPath,
@@ -1249,6 +1423,13 @@ var TailwindcssPatcher = (_class = 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;
@@ -1268,13 +1449,36 @@ var TailwindcssPatcher = (_class = 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 = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _64 => _64.write]), () => ( this.options.output.enabled));
+    const shouldWrite = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _69 => _69.write]), () => ( this.options.output.enabled));
     const classSet = await this.getClassSet();
     const classList = Array.from(classSet);
     const result = {
@@ -1301,6 +1505,22 @@ var TailwindcssPatcher = (_class = class {
   }
   // Backwards compatibility helper used by tests and API consumers.
   __init() {this.extractValidCandidates = exports.extractValidCandidates = extractValidCandidates}
+  async collectContentTokens(options) {
+    return extractProjectCandidatesWithPositions({
+      cwd: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.cwd]), () => ( this.options.projectRoot)),
+      sources: _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _71 => _71.sources]), () => ( _optionalChain([this, 'access', _72 => _72.options, 'access', _73 => _73.tailwind, 'access', _74 => _74.v4, 'optionalAccess', _75 => _75.sources]))), () => ( []))
+    });
+  }
+  async collectContentTokensByFile(options) {
+    const report = await this.collectContentTokens({
+      cwd: _optionalChain([options, 'optionalAccess', _76 => _76.cwd]),
+      sources: _optionalChain([options, 'optionalAccess', _77 => _77.sources])
+    });
+    return groupTokensByFile(report, {
+      key: _optionalChain([options, 'optionalAccess', _78 => _78.key]),
+      stripAbsolutePaths: _optionalChain([options, 'optionalAccess', _79 => _79.stripAbsolutePaths])
+    });
+  }
 }, _class);
 
 
@@ -1317,4 +1537,6 @@ var TailwindcssPatcher = (_class = class {
 
 
 
-exports.logger_default = logger_default; exports.CacheStore = CacheStore; exports.extractRawCandidatesWithPositions = extractRawCandidatesWithPositions; exports.extractRawCandidates = extractRawCandidates; exports.extractValidCandidates = extractValidCandidates; exports.fromLegacyOptions = fromLegacyOptions; exports.fromUnifiedConfig = fromUnifiedConfig; exports.normalizeOptions = normalizeOptions; exports.collectClassesFromContexts = collectClassesFromContexts; exports.collectClassesFromTailwindV4 = collectClassesFromTailwindV4; exports.loadRuntimeContexts = loadRuntimeContexts; exports.runTailwindBuild = runTailwindBuild; exports.TailwindcssPatcher = TailwindcssPatcher;
+
+
+exports.logger_default = logger_default; exports.CacheStore = CacheStore; exports.extractRawCandidatesWithPositions = extractRawCandidatesWithPositions; exports.extractRawCandidates = extractRawCandidates; exports.extractValidCandidates = extractValidCandidates; exports.extractProjectCandidatesWithPositions = extractProjectCandidatesWithPositions; exports.groupTokensByFile = groupTokensByFile; exports.fromLegacyOptions = fromLegacyOptions; exports.fromUnifiedConfig = fromUnifiedConfig; exports.normalizeOptions = normalizeOptions; exports.collectClassesFromContexts = collectClassesFromContexts; exports.collectClassesFromTailwindV4 = collectClassesFromTailwindV4; exports.loadRuntimeContexts = loadRuntimeContexts; exports.runTailwindBuild = runTailwindBuild; exports.TailwindcssPatcher = TailwindcssPatcher;