tailwind-canonical 0.5.0 → 0.7.0

package/dist/cli/cli.js

@@ -1,24 +1,50 @@
-import { watch as fsWatch, readFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { existsSync, watch as fsWatch, readFileSync, writeFileSync, } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { analyzeFile } from '../core/analyzer.js';
 import { toClassStringOpts } from '../core/class-strings.js';
-import { loadConfig } from '../core/config.js';
+import { CONFIG_FILENAMES, loadConfig, resolveInitFilename, } from '../core/config.js';
 import { analyzeConsistencyFiles, toConsistencyOptions, } from '../core/consistency.js';
-import { dedupeFile } from '../core/deduplicator.js';
-import { fixFile } from '../core/fixer.js';
-import { 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 { 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] [--analyze] [--typos] [--watch] [--reporter json|sarif] <dir|file> [dir|file...]';
+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_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:',
+    "  // customTextTokens: { 11: '2xs' },",
+    "  // 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 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',
     '  --sort             Sort classes into canonical order',
+    '  --check            Dry-run: report what transforms would change, write nothing (exit 1 on pending changes)',
     '  --analyze          Cross-file consistency analysis (read-only)',
     '  --typos            Flag likely misspelled color names (read-only)',
     '  --watch            Re-run on every file save (transform/check mode; ignored with --typos)',
@@ -92,6 +118,7 @@ const KNOWN_FLAGS = new Set([
     '--merge',
     '--dedup',
     '--sort',
+    '--check',
     '--watch',
     '--analyze',
     '--typos',
@@ -156,6 +183,7 @@ export function parseArgs(argv) {
         watch: argv.includes('--watch'),
         analyze: argv.includes('--analyze'),
         typos: argv.includes('--typos'),
+        check: argv.includes('--check'),
         help: argv.includes('--help') || argv.includes('-h'),
         version: argv.includes('--version') || argv.includes('-V'),
         reporter,
@@ -164,34 +192,29 @@ export function parseArgs(argv) {
         hasExplicitMode: MODE_FLAGS.some((flag) => argv.includes(flag)),
         hasExplicitReporter: reporterRaw !== undefined,
         hasExplicitWatch: argv.includes('--watch'),
+        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),
-        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 ?? []),
     };
 }
@@ -222,12 +245,19 @@ export function flagWarnings(flags) {
         }
         if (flags.typos)
             warnings.push('--typos ignored: --analyze takes priority');
+        if (flags.check)
+            warnings.push('--check ignored: --analyze takes priority');
         if (flags.watch)
             warnings.push('--watch ignored: not supported with --analyze');
         return warnings;
     }
-    if (flags.typos && flags.watch) {
-        warnings.push('--watch ignored: not supported with --typos');
+    if (flags.watch && (flags.typos || flags.check)) {
+        const unsupported = [];
+        if (flags.typos)
+            unsupported.push('--typos');
+        if (flags.check)
+            unsupported.push('--check');
+        warnings.push(`--watch ignored: not supported with ${unsupported.join('/')}`);
     }
     return warnings;
 }
@@ -295,19 +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);
+    let result = content;
+    if (flags.fix) {
+        const fixed = fixContent(result, config);
+        counts.fixed = fixed.count;
+        result = fixed.result;
+    }
+    if (flags.dedup) {
+        const deduped = dedupeContent(result, opts);
+        counts.deduped = deduped.count;
+        result = deduped.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 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;
 }
@@ -522,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)`);
@@ -534,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);
@@ -571,6 +657,20 @@ function startWatch(files, flags, config, sink) {
     });
     return { exitCode: 0, watching: true };
 }
+function runInit(cwd, sink) {
+    const existing = CONFIG_FILENAMES.find((name) => existsSync(join(cwd, name)));
+    if (existing) {
+        sink.error(`${existing} already exists`);
+        return { exitCode: 1 };
+    }
+    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.');
+    return { exitCode: 0 };
+}
 export async function run(argv, cwd, sink = defaultSink) {
     let flags = parseArgs(argv);
     if (flags.help) {
@@ -588,6 +688,21 @@ export async function run(argv, cwd, sink = defaultSink) {
             return { exitCode: 1 };
         }
     }
+    if (flags.targets[0] === 'init') {
+        if (flags.error ||
+            flags.hasExplicitMode ||
+            flags.hasExplicitWatch ||
+            flags.hasExplicitCheck ||
+            flags.hasExplicitReporter) {
+            sink.error('init takes no flags');
+            return { exitCode: 1 };
+        }
+        if (flags.targets.length > 1) {
+            sink.error('init takes no extra arguments');
+            return { exitCode: 1 };
+        }
+        return runInit(cwd, sink);
+    }
     if (flags.error) {
         sink.error(flags.error);
         return { exitCode: 1 };
@@ -605,9 +720,19 @@ export async function run(argv, cwd, sink = defaultSink) {
         sink.error(USAGE);
         return { exitCode: 1 };
     }
-    if (flags.merge && !flags.analyze && !flags.typos) {
+    if (flags.check &&
+        !flags.analyze &&
+        !flags.fix &&
+        !flags.dedup &&
+        !flags.merge &&
+        !flags.sort) {
+        sink.error('--check requires at least one of --fix, --dedup, --merge, --sort');
+        return { exitCode: 1 };
+    }
+    let twMerge;
+    if (flags.merge && !flags.analyze) {
         try {
-            await import('tailwind-merge');
+            ({ twMerge } = await import('tailwind-merge'));
         }
         catch {
             sink.error('--merge requires tailwind-merge: pnpm add -D tailwind-merge');
@@ -629,7 +754,7 @@ export async function run(argv, cwd, sink = defaultSink) {
     if (flags.typos && !transforming) {
         return runTypos(files, config, flags.reporter, sink);
     }
-    const watching = flags.watch && !flags.typos;
+    const watching = flags.watch && !flags.typos && !flags.check;
     const totals = { fixed: 0, deduped: 0, merged: 0, sorted: 0 };
     const allFindings = [];
     const changedFiles = [];
@@ -638,7 +763,9 @@ export async function run(argv, cwd, sink = defaultSink) {
         for (const file of files) {
             try {
                 if (transforming) {
-                    const counts = await processFile(file, flags, config);
+                    const counts = flags.check
+                        ? 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;
@@ -646,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(`  fixed  ${file} (${pluralize(counts.fixed, 'replacement')})`);
-                        if (counts.deduped > 0)
-                            sink.log(`  deduped ${file} (${pluralize(counts.deduped, 'class string')})`);
-                        if (counts.merged > 0)
-                            sink.log(`  merged ${file} (${pluralize(counts.merged, 'conflict')})`);
-                        if (counts.sorted > 0)
-                            sink.log(`  sorted ${file} (${pluralize(counts.sorted, 'class string')})`);
+                        logTransformCounts(counts, file, flags.check, sink);
                     }
                 }
                 else {
@@ -674,12 +794,14 @@ 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)
             : undefined;
+        const totalChanges = totalOf(totals);
         const exitCode = hadError ||
+            (flags.check && totalChanges > 0) ||
             (typoResult && (typoResult.findings.length > 0 || typoResult.hadError))
             ? 1
             : 0;
@@ -692,6 +814,8 @@ export async function run(argv, cwd, sink = defaultSink) {
                 merged: totals.merged,
                 sorted: totals.sorted,
             };
+            if (flags.check)
+                report.check = true;
             if (typoResult) {
                 report.typoTotal = typoResult.findings.length;
                 report.typos = typoResult.findings;
@@ -706,16 +830,26 @@ export async function run(argv, cwd, sink = defaultSink) {
             sink.write(`${JSON.stringify(doc, null, 2)}\n`);
             return { exitCode };
         }
-        const parts = [];
-        if (flags.fix)
-            parts.push(pluralize(totals.fixed, 'replacement'));
-        if (flags.dedup)
-            parts.push(pluralize(totals.deduped, 'dedup'));
-        if (flags.merge)
-            parts.push(`${pluralize(totals.merged, 'conflict')} merged`);
-        if (flags.sort)
-            parts.push(`${totals.sorted} sorted`);
-        sink.log(`\n✓ Fixed ${parts.join(', ')} across ${pluralize(files.length, 'file')}`);
+        if (flags.check) {
+            if (totalChanges > 0) {
+                sink.log(`\n✖ ${pluralize(totalChanges, 'pending change')} across ${pluralize(changedFiles.length, 'file')} (run without --check to apply)`);
+            }
+            else {
+                sink.log('✓ No pending changes');
+            }
+        }
+        else {
+            const parts = [];
+            if (flags.fix)
+                parts.push(pluralize(totals.fixed, 'replacement'));
+            if (flags.dedup)
+                parts.push(pluralize(totals.deduped, 'dedup'));
+            if (flags.merge)
+                parts.push(`${pluralize(totals.merged, 'conflict')} merged`);
+            if (flags.sort)
+                parts.push(`${totals.sorted} sorted`);
+            sink.log(`\n✓ Fixed ${parts.join(', ')} across ${pluralize(files.length, 'file')}`);
+        }
         if (typoResult)
             logTyposText(typoResult.findings, sink);
         return { exitCode };
@@ -771,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',
@@ -35,6 +38,7 @@ const DEFAULT_COMMAND_KEYS = [
     'merge',
     'dedup',
     'sort',
+    'check',
     'analyze',
     'typos',
     'watch',
@@ -116,6 +120,7 @@ function assertDefaultCommandConfig(value, filename) {
         'merge',
         'dedup',
         'sort',
+        'check',
         'analyze',
         'typos',
         'watch',
@@ -181,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