tailwind-canonical 0.6.0 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 Lint and auto-fix Tailwind CSS classes: arbitrary values → canonical, deduplication, shorthand collapsing, and class sorting.
 
-> Compatible with Tailwind CSS v3.3+ and v4 — zero `tailwindcss` dependency (conventions are built in). Custom theme tokens are supported via config.
+> Compatible with Tailwind CSS v4 out of the box, and with v3.3+ via [`tailwindVersion: 3`](#tailwind-v3-vs-v4-tailwindversion) — the ÷4 spacing rule assumes v4's dynamic scale, so v3 projects must set it. Zero `tailwindcss` dependency (conventions are built in). Custom theme tokens are supported via config.
 
 ## Install
 
@@ -50,7 +50,7 @@ For pre-commit automation, see the [Pre-commit hook](#pre-commit-hook-husky--lef
 ## CLI
 
 ```bash
-# Scaffold a tailwind-canonical.config.ts in the current directory
+# Scaffold a config in the current directory (.ts, or .js/.mjs on older Node)
 npx tailwind-canonical init
 
 # Check for non-canonical arbitrary values
@@ -356,6 +356,52 @@ left-2 right-2                  → inset-x-2
 
 Non-divisible values (`h-[22px]`, `px-[7px]`) are left untouched.
 
+### Tailwind v3 vs v4 (`tailwindVersion`)
+
+The ÷4 spacing rule assumes the **v4** scale, where every step is derived from
+`calc(var(--spacing) * n)` and any integer works. v3 ships a discrete scale, so
+`p-[52px]` → `p-13` compiles to nothing at all on v3 and the padding silently
+disappears. Set `tailwindVersion: 3` on a v3 project:
+
+```ts
+export default {
+  tailwindVersion: 3, // default: 4
+}
+```
+
+In v3 mode, suggestions are restricted to what v3.3 actually generates — the
+scale differs per utility, not just per family:
+
+| Class | `tailwindVersion: 4` | `tailwindVersion: 3` |
+|---|---|---|
+| `p-[16px]` | `p-4` | `p-4` |
+| `p-[52px]` | `p-13` | untouched — not on the v3 scale |
+| `max-w-[16px]` | `max-w-4` | untouched — scale arrived after v3.3 |
+| `max-w-[0px]` | `max-w-0` | `max-w-0` — the zero step does exist |
+| `size-[16px]` | `size-4` | untouched — no scale at all in v3.3 |
+| `max-h-[16px]` | `max-h-4` | `max-h-4` |
+| `max-w-[50%]` | `max-w-1/2` | untouched — no fractions in v3.3 |
+| `top-[20%]` | `top-1/5` | untouched — v3.3 stops at quarters here |
+| `top-[25%]` | `top-1/4` | `top-1/4` |
+| `w-[8.333333%]` | `w-1/12` | `w-1/12` — `w` carries the full set |
+
+Spacing steps: `size-*` has no numeric scale in v3.3, and `min-w-*`, `max-w-*`
+and `min-h-*` only ship the zero step — they gained the scale afterwards.
+Fractions: `w` carries all thirteen, `h` stops at sixths, `inset`/`top`/`left`/
+`right`/`bottom`/`translate-x`/`translate-y` only have halves, thirds and
+quarters, and `min-w`/`max-w`/`min-h`/`max-h` have none.
+
+`text-*`, `rounded-*` and `opacity-*` are identical in both majors and are
+never gated. `customSpacingTokens` stays your decision and is applied in both
+modes. All of the above was measured against `tailwindcss@3.3.7`, the
+advertised floor.
+
+**On v3.4**, keep `tailwindVersion: 3`. v3.4 added the numeric scale to
+`size-*`, `min-w-*`, `max-w-*` and `min-h-*`, but its spacing scale is still
+discrete — `p-13` does not exist there either. So v3 mode is the safe setting
+and merely leaves a few v3.4-valid suggestions on the table; `tailwindVersion:
+4` would emit steps v3.4 cannot generate.
+
 ## Config
 
 Create `tailwind-canonical.config.ts` at the root:
@@ -369,6 +415,8 @@ export default {
   customSpacingTokens: {
     14: '3.5',
   },
+  // Target Tailwind major: 3 restricts suggestions to the v3 scale (default: 4)
+  tailwindVersion: 4,
   // Support non-React attribute patterns (default: ['className'])
   attributeNames: ['className', 'class', ':class', 'tw'],
   // Support utility function wrappers
@@ -420,8 +468,15 @@ files and at most 3 times.
 The older top-level rare-value keys are still accepted for compatibility, but
 new configs should prefer `analyze`.
 
-`tailwind-canonical.config.js` is still loaded as a fallback when no TypeScript
-config exists.
+Accepted filenames, in resolution order: `tailwind-canonical.config.ts`,
+`.mts`, `.js`, `.mjs`.
+
+A `.ts` or `.mts` config needs Node's type stripping, which is on by default
+from Node 22.18 and 23.6, and available behind `--experimental-strip-types`
+from 22.6. Short of that use `.mjs`, or `.js` when your nearest `package.json`
+declares `"type": "module"`; both load on every supported Node. `tailwind-
+canonical init` scaffolds a filename that loads on a bare `node` — it will not
+write `.ts` just because the process it runs in happens to carry the flag.
 
 The config is resolved upward from the current directory: if no config file is
 found in `cwd`, tailwind-canonical checks each parent directory in turn, until
@@ -429,10 +484,6 @@ it finds one, reaches a `.git` directory, or reaches the filesystem root. This
 makes the CLI monorepo-friendly — a single config at the repo root applies to
 every package.
 
-On Node 22.6–23.5, loading a `.ts` config requires `--experimental-strip-types`;
-from Node 23.6 onward it works natively; the `.js` fallback works on every
-supported Node version.
-
 ## ESLint plugin
 
 ```js
@@ -531,15 +582,37 @@ Detects unused exports, files, and dependencies. Config in `knip.json`. Enforced
 
 ```ts
 import {
-  suggestCanonical,   // pure: class string → suggestion or null
-  analyzeFile,        // find non-canonical classes in a file
-  fixFile,            // apply --fix in-place
-  deduplicateClasses, // pure: deduplicate a class string
-  dedupeFile,         // apply --dedup in-place
-  sortClasses,        // pure: sort a class string
-  sortFile,           // apply --sort in-place
-  mergeFile,          // apply --merge in-place (requires tailwind-merge)
-  scanFiles,          // recursive file scanner (sync, dir/file targets)
-  resolveTargets,     // async glob resolver with negation + brace expansion
+  suggestCanonical,    // pure: class string → suggestion or null
+  analyzeFile,         // find non-canonical classes in a file
+  fixFile,             // apply --fix in-place
+  deduplicateClasses,  // pure: deduplicate a class string
+  dedupeFile,          // apply --dedup in-place
+  sortClasses,         // pure: sort a class string
+  sortFile,            // apply --sort in-place
+  DEFAULT_SORT_ORDER,  // default sort category order (override via config sortOrder)
+  mergeFile,           // apply --merge in-place (requires tailwind-merge)
+  scanFiles,           // recursive file scanner (sync, dir/file targets)
+  resolveTargets,      // async glob resolver with negation + brace expansion
+  loadConfig,          // load + validate tailwind-canonical.config.{ts,mts,js,mjs} for a cwd
+  analyzeConsistency,  // pure: cross-file consistency analysis (--analyze)
+  analyzeTyposFile,    // find likely color-name typos in a file
+  detectTypo,          // pure: check one class for a likely color-name typo
+} from 'tailwind-canonical'
+
+import type {
+  Config,             // shared config object accepted across the API
+  Suggestion,         // suggestCanonical's non-null return shape
+  Finding,            // one entry returned by analyzeFile
+  ScanOptions,        // extensions/ignore options for scanFiles/resolveTargets
+  SortCategory,       // one entry of DEFAULT_SORT_ORDER / config.sortOrder
+  TypoFinding,        // one entry returned by analyzeTyposFile
+  ConsistencyOptions, // options accepted by analyzeConsistency
+  ConsistencyReport,  // analyzeConsistency's return shape
+  FileClasses,        // per-file input shape for analyzeConsistency
+  ColorVariant,       // one variant inside a ConsistencyReport color group
+  ColorVariantGroup,  // one color-family group in ConsistencyReport.colorVariants
+  ScaleInconsistency, // one entry in ConsistencyReport.scaleInconsistencies
+  ScaleValue,         // one value inside a ScaleInconsistency
+  ClassCombination,   // one repeated-pattern entry in ConsistencyReport.combinations
 } from 'tailwind-canonical'
 ```

package/dist/cli/cli.d.ts

@@ -38,4 +38,3 @@ export declare function parseArgs(argv: string[]): Flags;
 export declare function flagWarnings(flags: Flags): string[];
 export declare function run(argv: string[], cwd: string, sink?: Sink): Promise<RunResult>;
 export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli/cli.js

@@ -2,20 +2,17 @@ import { existsSync, watch as fsWatch, readFileSync, writeFileSync, } from 'node
 import { dirname, join, resolve } from 'node:path';
 import { analyzeFile } from '../core/analyzer.js';
 import { toClassStringOpts } from '../core/class-strings.js';
-import { CONFIG_FILENAMES, loadConfig } from '../core/config.js';
+import { CONFIG_FILENAMES, loadConfig, resolveInitFilename, } from '../core/config.js';
 import { analyzeConsistencyFiles, toConsistencyOptions, } from '../core/consistency.js';
-import { dedupeContent, dedupeFile } from '../core/deduplicator.js';
-import { fixContent, fixFile } from '../core/fixer.js';
-import { mergeContent, mergeFile } from '../core/merger.js';
+import { dedupeContent } from '../core/deduplicator.js';
+import { fixContent } from '../core/fixer.js';
+import { mergeContent } from '../core/merger.js';
 import { resolveTargets } from '../core/scanner.js';
-import { sortContent, sortFile } from '../core/sorter.js';
+import { sortContent } from '../core/sorter.js';
 import { analyzeTyposFile } from '../core/typos.js';
 const SARIF_SCHEMA = 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json';
 const USAGE = 'Usage: tailwind-canonical [--fix] [--merge] [--dedup] [--sort] [--check] [--analyze] [--typos] [--watch] [--reporter json|sarif] <dir|file> [dir|file...]\n       tailwind-canonical init';
-const INIT_CONFIG_CONTENT = [
-    "import type { Config } from 'tailwind-canonical'",
-    '',
-    'export default {',
+const INIT_CONFIG_BODY = [
     '  // Run `tailwind-canonical` with no flags using these defaults:',
     "  // defaultCommand: { fix: true, dedup: true, sort: true, typos: true, targets: ['./src'] },",
     '  // px → token additions/overrides:',
@@ -23,13 +20,26 @@ const INIT_CONFIG_CONTENT = [
     "  // customSpacingTokens: { 14: '3.5' },",
     '  // Never suggest replacements for classes matching:',
     '  // ignorePatterns: [/^font-/],',
+];
+const INIT_CONFIG_TS = [
+    "import type { Config } from 'tailwind-canonical'",
+    '',
+    'export default {',
+    ...INIT_CONFIG_BODY,
     '} satisfies Config',
     '',
 ].join('\n');
+const INIT_CONFIG_JS = [
+    "/** @type {import('tailwind-canonical').Config} */",
+    'export default {',
+    ...INIT_CONFIG_BODY,
+    '}',
+    '',
+].join('\n');
 const HELP_TEXT = [
     USAGE,
     '',
-    '  init               Create a tailwind-canonical.config.ts scaffold in the current directory',
+    '  init               Create a tailwind-canonical config scaffold in the current directory',
     '  --fix              Auto-replace arbitrary values with canonical Tailwind classes',
     '  --dedup            Remove redundant classes and collapse shorthands',
     '  --merge            Resolve conflicting classes via tailwind-merge',
@@ -185,35 +195,26 @@ export function parseArgs(argv) {
         hasExplicitCheck: argv.includes('--check'),
     };
 }
+/** Explicit CLI flags win; otherwise `defaultCommand` fills the gap. */
+function fallback(explicit, flag, configured) {
+    return explicit ? flag : (configured ?? flag);
+}
 function applyDefaultCommand(flags, config) {
     const defaults = config.defaultCommand;
     if (!defaults)
         return flags;
+    const mode = flags.hasExplicitMode;
     return {
         ...flags,
-        fix: flags.hasExplicitMode ? flags.fix : (defaults.fix ?? flags.fix),
-        merge: flags.hasExplicitMode
-            ? flags.merge
-            : (defaults.merge ?? flags.merge),
-        dedup: flags.hasExplicitMode
-            ? flags.dedup
-            : (defaults.dedup ?? flags.dedup),
-        sort: flags.hasExplicitMode ? flags.sort : (defaults.sort ?? flags.sort),
-        analyze: flags.hasExplicitMode
-            ? flags.analyze
-            : (defaults.analyze ?? flags.analyze),
-        typos: flags.hasExplicitMode
-            ? flags.typos
-            : (defaults.typos ?? flags.typos),
-        watch: flags.hasExplicitWatch
-            ? flags.watch
-            : (defaults.watch ?? flags.watch),
-        check: flags.hasExplicitCheck
-            ? flags.check
-            : (defaults.check ?? flags.check),
-        reporter: flags.hasExplicitReporter
-            ? flags.reporter
-            : (defaults.reporter ?? flags.reporter),
+        fix: fallback(mode, flags.fix, defaults.fix),
+        merge: fallback(mode, flags.merge, defaults.merge),
+        dedup: fallback(mode, flags.dedup, defaults.dedup),
+        sort: fallback(mode, flags.sort, defaults.sort),
+        analyze: fallback(mode, flags.analyze, defaults.analyze),
+        typos: fallback(mode, flags.typos, defaults.typos),
+        watch: fallback(flags.hasExplicitWatch, flags.watch, defaults.watch),
+        check: fallback(flags.hasExplicitCheck, flags.check, defaults.check),
+        reporter: fallback(flags.hasExplicitReporter, flags.reporter, defaults.reporter),
         targets: flags.targets.length > 0 ? flags.targets : (defaults.targets ?? []),
     };
 }
@@ -324,45 +325,79 @@ function runTypos(files, config, reporter, sink) {
     logTyposText(findings, sink);
     return { exitCode: findings.length > 0 || hadError ? 1 : 0 };
 }
-async function processFile(file, flags, config) {
+function applyTransforms(content, flags, config, twMerge) {
     const opts = toClassStringOpts(config);
     const counts = { fixed: 0, deduped: 0, merged: 0, sorted: 0 };
-    if (flags.fix)
-        counts.fixed = fixFile(file, config);
-    if (flags.dedup)
-        counts.deduped = dedupeFile(file, opts);
-    if (flags.merge)
-        counts.merged = await mergeFile(file, opts);
-    if (flags.sort)
-        counts.sorted = sortFile(file, opts, config.sortOrder);
-    return counts;
-}
-async function checkFile(file, flags, config, twMerge) {
-    const opts = toClassStringOpts(config);
-    const counts = { fixed: 0, deduped: 0, merged: 0, sorted: 0 };
-    let content = readFileSync(file, 'utf8');
+    let result = content;
     if (flags.fix) {
-        const { result, count } = fixContent(content, config);
-        counts.fixed = count;
-        content = result;
+        const fixed = fixContent(result, config);
+        counts.fixed = fixed.count;
+        result = fixed.result;
     }
     if (flags.dedup) {
-        const { result, count } = dedupeContent(content, opts);
-        counts.deduped = count;
-        content = result;
+        const deduped = dedupeContent(result, opts);
+        counts.deduped = deduped.count;
+        result = deduped.result;
     }
-    if (flags.merge && twMerge) {
-        const { result, count } = mergeContent(content, twMerge, opts);
-        counts.merged = count;
-        content = result;
+    if (flags.merge) {
+        if (!twMerge) {
+            throw new Error('--merge requires the optional peer dependency "tailwind-merge". Install it with: pnpm add -D tailwind-merge');
+        }
+        const merged = mergeContent(result, twMerge, opts);
+        counts.merged = merged.count;
+        result = merged.result;
     }
     if (flags.sort) {
-        const { result, count } = sortContent(content, opts, config.sortOrder);
-        counts.sorted = count;
-        content = result;
+        const sorted = sortContent(result, opts, config.sortOrder);
+        counts.sorted = sorted.count;
+        result = sorted.result;
     }
+    return { counts, result };
+}
+function processFile(file, flags, config, twMerge) {
+    const content = readFileSync(file, 'utf8');
+    const { counts, result } = applyTransforms(content, flags, config, twMerge);
+    // Counts, not text equality: replaceClassStrings also normalizes attribute
+    // spacing, which no transform counts. Writing on any textual difference
+    // would rewrite files that --check truthfully reports as clean.
+    if (totalOf(counts) > 0)
+        writeFileSync(file, result, 'utf8');
     return counts;
 }
+const TRANSFORM_LABELS = [
+    {
+        key: 'fixed',
+        applied: 'fixed ',
+        pending: 'would fix',
+        unit: 'replacement',
+    },
+    {
+        key: 'deduped',
+        applied: 'deduped',
+        pending: 'would dedup',
+        unit: 'class string',
+    },
+    {
+        key: 'merged',
+        applied: 'merged ',
+        pending: 'would merge',
+        unit: 'conflict',
+    },
+    {
+        key: 'sorted',
+        applied: 'sorted ',
+        pending: 'would sort',
+        unit: 'class string',
+    },
+];
+function logTransformCounts(counts, file, check, sink) {
+    for (const { key, applied, pending, unit } of TRANSFORM_LABELS) {
+        const count = counts[key];
+        if (count > 0) {
+            sink.log(`  ${check ? pending : applied} ${file} (${pluralize(count, unit)})`);
+        }
+    }
+}
 function totalOf(c) {
     return c.fixed + c.deduped + c.merged + c.sorted;
 }
@@ -577,10 +612,9 @@ function runAnalyze(files, config, reporter, sink) {
     logAnalyzeText(report, issueCount, config, sink);
     return { exitCode: issueCount > 0 || hadError ? 1 : 0 };
 }
-function startWatch(files, flags, config, sink) {
+function startWatch(files, flags, config, twMerge, sink) {
     const transforming = flags.fix || flags.dedup || flags.merge || flags.sort;
     const fileSet = new Set(files);
-    const inFlight = new Set();
     const timers = new Map();
     const dirs = new Set(files.map((f) => dirname(f)));
     sink.log(`Watching ${pluralize(files.length, 'file')}... (Ctrl+C to stop)`);
@@ -589,23 +623,20 @@ function startWatch(files, flags, config, sink) {
             if (!filename)
                 return;
             const full = resolve(dir, filename);
-            if (!fileSet.has(full) || inFlight.has(full))
+            if (!fileSet.has(full))
                 return;
             clearTimeout(timers.get(full));
             timers.set(full, setTimeout(() => {
                 if (transforming) {
-                    inFlight.add(full);
-                    processFile(full, flags, config)
-                        .then((counts) => {
-                        const total = totalOf(counts);
+                    try {
+                        const total = totalOf(processFile(full, flags, config, twMerge));
                         if (total > 0) {
                             sink.log(`${timestamp()} ${full} — ${pluralize(total, 'change')} applied`);
                         }
-                    })
-                        .catch((err) => {
-                        sink.error(`${timestamp()} ${full} — error: ${err instanceof Error ? err.message : String(err)}`);
-                    })
-                        .finally(() => inFlight.delete(full));
+                    }
+                    catch (err) {
+                        sink.error(`${timestamp()} ${full} — error: ${errMsg(err)}`);
+                    }
                 }
                 else {
                     const findings = analyzeFile(full, config);
@@ -632,8 +663,9 @@ function runInit(cwd, sink) {
         sink.error(`${existing} already exists`);
         return { exitCode: 1 };
     }
-    const filename = CONFIG_FILENAMES[0];
-    writeFileSync(join(cwd, filename), INIT_CONFIG_CONTENT, 'utf8');
+    const filename = resolveInitFilename(cwd);
+    const content = /\.m?ts$/.test(filename) ? INIT_CONFIG_TS : INIT_CONFIG_JS;
+    writeFileSync(join(cwd, filename), content, 'utf8');
     sink.log(`Created ${filename}`);
     sink.log('Uncomment defaultCommand to set your CLI defaults.');
     sink.log('Then run `npx tailwind-canonical` to lint your project.');
@@ -732,8 +764,8 @@ export async function run(argv, cwd, sink = defaultSink) {
             try {
                 if (transforming) {
                     const counts = flags.check
-                        ? await checkFile(file, flags, config, twMerge)
-                        : await processFile(file, flags, config);
+                        ? applyTransforms(readFileSync(file, 'utf8'), flags, config, twMerge).counts
+                        : processFile(file, flags, config, twMerge);
                     totals.fixed += counts.fixed;
                     totals.deduped += counts.deduped;
                     totals.merged += counts.merged;
@@ -741,14 +773,7 @@ export async function run(argv, cwd, sink = defaultSink) {
                     if (totalOf(counts) > 0)
                         changedFiles.push(file);
                     if (flags.reporter === 'text') {
-                        if (counts.fixed > 0)
-                            sink.log(`  ${flags.check ? 'would fix' : 'fixed '} ${file} (${pluralize(counts.fixed, 'replacement')})`);
-                        if (counts.deduped > 0)
-                            sink.log(`  ${flags.check ? 'would dedup' : 'deduped'} ${file} (${pluralize(counts.deduped, 'class string')})`);
-                        if (counts.merged > 0)
-                            sink.log(`  ${flags.check ? 'would merge' : 'merged '} ${file} (${pluralize(counts.merged, 'conflict')})`);
-                        if (counts.sorted > 0)
-                            sink.log(`  ${flags.check ? 'would sort' : 'sorted '} ${file} (${pluralize(counts.sorted, 'class string')})`);
+                        logTransformCounts(counts, file, flags.check, sink);
                     }
                 }
                 else {
@@ -769,7 +794,7 @@ export async function run(argv, cwd, sink = defaultSink) {
         }
     }
     if (watching)
-        return startWatch(files, flags, config, sink);
+        return startWatch(files, flags, config, twMerge, sink);
     if (transforming) {
         const typoResult = flags.typos
             ? collectTypos(files, config, sink)
@@ -880,4 +905,3 @@ export async function run(argv, cwd, sink = defaultSink) {
     sink.log('✓ No non-canonical classes found');
     return { exitCode: hadError ? 1 : 0 };
 }
-//# sourceMappingURL=cli.js.map

package/dist/cli/index.d.ts

@@ -1,3 +1,2 @@
 #!/usr/bin/env node
 export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -3,4 +3,3 @@ import { run } from './cli.js';
 const { exitCode, watching } = await run(process.argv.slice(2), process.cwd());
 if (!watching)
     process.exit(exitCode);
-//# sourceMappingURL=index.js.map

package/dist/core/analyzer.d.ts

@@ -7,4 +7,3 @@ export type Finding = {
 };
 export declare function analyzeContent(filePath: string, content: string, config?: Config): Finding[];
 export { analyzeFile } from '../io/analyzer.js';
-//# sourceMappingURL=analyzer.d.ts.map

package/dist/core/analyzer.js

@@ -20,4 +20,3 @@ export function analyzeContent(filePath, content, config = {}) {
     return findings;
 }
 export { analyzeFile } from '../io/analyzer.js';
-//# sourceMappingURL=analyzer.js.map

package/dist/core/class-strings.d.ts

@@ -20,4 +20,3 @@ export declare function extractClassStrings(content: string, opts?: ClassStringO
     start: number;
     end: number;
 }>;
-//# sourceMappingURL=class-strings.d.ts.map

package/dist/core/class-strings.js

@@ -149,4 +149,3 @@ export function extractClassStrings(content, opts = {}) {
     }
     return results;
 }
-//# sourceMappingURL=class-strings.js.map

package/dist/core/config.d.ts

@@ -1,5 +1,4 @@
 import type { Config } from './rules.js';
-export declare const CONFIG_FILENAMES: readonly ["tailwind-canonical.config.ts", "tailwind-canonical.config.js"];
+export declare const CONFIG_FILENAMES: readonly ["tailwind-canonical.config.ts", "tailwind-canonical.config.mts", "tailwind-canonical.config.js", "tailwind-canonical.config.mjs"];
 export declare function validateConfig(input: unknown, filename?: string): Config;
-export { loadConfig } from '../io/config.js';
-//# sourceMappingURL=config.d.ts.map
+export { loadConfig, resolveInitFilename } from '../io/config.js';

package/dist/core/config.js

@@ -2,7 +2,9 @@ import { DEFAULT_SORT_ORDER } from './sorter.js';
 const CONFIG_FILENAME = 'tailwind-canonical.config.ts';
 export const CONFIG_FILENAMES = [
     CONFIG_FILENAME,
+    'tailwind-canonical.config.mts',
     'tailwind-canonical.config.js',
+    'tailwind-canonical.config.mjs',
 ];
 const KNOWN_KEYS = [
     'customTextTokens',
@@ -19,6 +21,7 @@ const KNOWN_KEYS = [
     'rareScaleMaxFiles',
     'rareScaleMaxCount',
     'defaultCommand',
+    'tailwindVersion',
 ];
 const ANALYZE_KEYS = [
     'minRareScalePropertyOccurrences',
@@ -183,7 +186,11 @@ export function validateConfig(input, filename = CONFIG_FILENAME) {
         assertPositiveInteger(cfg.rareScaleMaxCount, 'rareScaleMaxCount', filename);
     if ('defaultCommand' in cfg)
         assertDefaultCommandConfig(cfg.defaultCommand, filename);
+    if ('tailwindVersion' in cfg &&
+        cfg.tailwindVersion !== 3 &&
+        cfg.tailwindVersion !== 4) {
+        fail(filename, 'tailwindVersion must be 3 or 4');
+    }
     return cfg;
 }
-export { loadConfig } from '../io/config.js';
-//# sourceMappingURL=config.js.map
+export { loadConfig, resolveInitFilename } from '../io/config.js';

package/dist/core/consistency.d.ts

@@ -60,4 +60,3 @@ export declare function analyzeConsistency(input: FileClasses[], options?: Consi
 export declare function collectClasses(content: string, opts?: ClassStringOpts): string[];
 export declare function toConsistencyOptions(config?: Config): ConsistencyOptions;
 export { analyzeConsistencyFiles } from '../io/consistency.js';
-//# sourceMappingURL=consistency.d.ts.map

package/dist/core/consistency.js

@@ -1,9 +1,5 @@
 import { extractClassStrings, SINGLE_CLASS_REGEX, } from './class-strings.js';
-import { COLOR_FAMILIES, parseColorClass, SCALE_PROPERTIES, TAILWIND_COLORS, } from './lexicon.js';
-function stripVariants(cls) {
-    const idx = cls.lastIndexOf(':');
-    return idx === -1 ? cls : cls.slice(idx + 1);
-}
+import { COLOR_FAMILIES, parseColorClass, SCALE_PROPERTIES, stripVariants, TAILWIND_COLORS, } from './lexicon.js';
 function parseColor(cls, families, knownColors) {
     const parsed = parseColorClass(cls);
     if (!parsed)
@@ -223,4 +219,3 @@ export function toConsistencyOptions(config = {}) {
     };
 }
 export { analyzeConsistencyFiles } from '../io/consistency.js';
-//# sourceMappingURL=consistency.js.map

package/dist/core/deduplicator.d.ts

@@ -5,4 +5,3 @@ export declare function dedupeContent(content: string, opts?: ClassStringOpts):
     count: number;
 };
 export { dedupeFile } from '../io/deduplicator.js';
-//# sourceMappingURL=deduplicator.d.ts.map

package/dist/core/deduplicator.js

@@ -300,10 +300,15 @@ function collapseCorners(c) {
 }
 // ─── Responsive cascade collapse ─────────────────────────────────────────────
 const RESPONSIVE_BREAKPOINTS = ['sm', 'md', 'lg', 'xl', '2xl'];
-const BP_ORDER = [
-    '',
-    ...RESPONSIVE_BREAKPOINTS,
-];
+// Exhaustive by type: adding a breakpoint above fails the build until ranked.
+const BP_RANK = {
+    '': 0,
+    sm: 1,
+    md: 2,
+    lg: 3,
+    xl: 4,
+    '2xl': 5,
+};
 function collapseResponsiveCascade(classes) {
     // Last-wins keyword utilities (display, position) share a single CSS property
     // even though their class names differ, so they must group by property — not
@@ -339,7 +344,7 @@ function collapseResponsiveCascade(classes) {
     for (const group of groups.values()) {
         if (group.length < 2 || !group.some((e) => e.bp !== ''))
             continue;
-        const sorted = [...group].sort((a, b) => BP_ORDER.indexOf(a.bp) - BP_ORDER.indexOf(b.bp));
+        const sorted = [...group].sort((a, b) => BP_RANK[a.bp] - BP_RANK[b.bp]);
         let prev = null;
         for (const entry of sorted) {
             if (entry.base === prev) {
@@ -439,4 +444,3 @@ export function dedupeContent(content, opts = {}) {
     });
 }
 export { dedupeFile } from '../io/deduplicator.js';
-//# sourceMappingURL=deduplicator.js.map

package/dist/core/fixer.d.ts

@@ -4,4 +4,3 @@ export declare function fixContent(content: string, config?: Config): {
     count: number;
 };
 export { fixFile } from '../io/fixer.js';
-//# sourceMappingURL=fixer.d.ts.map

package/dist/core/fixer.js

@@ -18,4 +18,3 @@ export function fixContent(content, config = {}) {
     return { result, count };
 }
 export { fixFile } from '../io/fixer.js';
-//# sourceMappingURL=fixer.js.map

package/dist/core/lexicon.d.ts

@@ -1,5 +1,6 @@
 export declare const TAILWIND_COLORS: Set<string>;
 export declare const COLOR_FAMILIES: Record<string, string>;
+export declare function stripVariants(cls: string): string;
 /**
  * Parses a color utility class into its property, color name and (optional)
  * numeric shade. Strips leading variants (`hover:` …). Returns `null` when the
@@ -13,4 +14,3 @@ export declare function parseColorClass(cls: string): {
     shade: string;
 } | null;
 export declare const SCALE_PROPERTIES: Set<string>;
-//# sourceMappingURL=lexicon.d.ts.map

package/dist/core/lexicon.js

@@ -70,7 +70,7 @@ export const COLOR_FAMILIES = {
     neutral: 'gray',
     stone: 'gray',
 };
-function stripVariants(cls) {
+export function stripVariants(cls) {
     const idx = cls.lastIndexOf(':');
     return idx === -1 ? cls : cls.slice(idx + 1);
 }
@@ -136,4 +136,3 @@ export const SCALE_PROPERTIES = new Set([
     'space-y',
     'z',
 ]);
-//# sourceMappingURL=lexicon.js.map

package/dist/core/merger.d.ts

@@ -4,4 +4,3 @@ export declare function mergeContent(content: string, twMerge: (classes: string)
     count: number;
 };
 export { mergeFile } from '../io/merger.js';
-//# sourceMappingURL=merger.d.ts.map