tailwind-canonical 0.6.0 → 0.7.1

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',
@@ -29,8 +32,7 @@ const ANALYZE_KEYS = [
     'maxRareValues',
     'maxPatterns',
 ];
-const ANALYZE_KEY_SET = new Set(ANALYZE_KEYS);
-const DEFAULT_COMMAND_KEYS = [
+const DEFAULT_COMMAND_BOOLEAN_KEYS = [
     'fix',
     'merge',
     'dedup',
@@ -39,21 +41,29 @@ const DEFAULT_COMMAND_KEYS = [
     'analyze',
     'typos',
     'watch',
+];
+const DEFAULT_COMMAND_KEYS = [
+    ...DEFAULT_COMMAND_BOOLEAN_KEYS,
     'reporter',
     'targets',
 ];
-const DEFAULT_COMMAND_KEY_SET = new Set(DEFAULT_COMMAND_KEYS);
 const REPORTERS = new Set(['text', 'json', 'sarif']);
-const KNOWN_KEY_SET = new Set(KNOWN_KEYS);
 const SORT_CATEGORIES = new Set(DEFAULT_SORT_ORDER);
-function invalidConfig(filename, message) {
-    return new Error(`Invalid ${filename}: ${message}`);
-}
 function fail(filename, message) {
-    throw invalidConfig(filename, message);
+    throw new Error(`Invalid ${filename}: ${message}`);
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function assertKnownKeys(cfg, known, label, filename) {
+    for (const key of Object.keys(cfg)) {
+        if (!known.includes(key)) {
+            fail(filename, `${label} "${key}" (expected one of: ${known.join(', ')})`);
+        }
+    }
 }
 function assertPxTokenMap(value, key, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value)) {
         fail(filename, `${key} must be an object mapping px numbers to token names`);
     }
     for (const [k, v] of Object.entries(value)) {
@@ -74,7 +84,7 @@ function assertRegExpArray(value, key, filename) {
     }
 }
 function assertStringRecord(value, key, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value)) {
         fail(filename, `${key} must be an object mapping strings to strings`);
     }
     for (const [k, v] of Object.entries(value)) {
@@ -88,40 +98,20 @@ function assertPositiveInteger(value, key, filename) {
     }
 }
 function assertAnalyzeConfig(value, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value))
         fail(filename, 'analyze must be an object');
-    }
-    const cfg = value;
-    for (const key of Object.keys(cfg)) {
-        if (!ANALYZE_KEY_SET.has(key)) {
-            fail(filename, `analyze contains unknown key "${key}" (expected one of: ${ANALYZE_KEYS.join(', ')})`);
-        }
-    }
+    assertKnownKeys(value, ANALYZE_KEYS, 'analyze contains unknown key', filename);
     for (const key of ANALYZE_KEYS) {
-        if (key in cfg)
-            assertPositiveInteger(cfg[key], `analyze.${key}`, filename);
+        if (key in value)
+            assertPositiveInteger(value[key], `analyze.${key}`, filename);
     }
 }
 function assertDefaultCommandConfig(value, filename) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    if (!isPlainObject(value))
         fail(filename, 'defaultCommand must be an object');
-    }
     const cfg = value;
-    for (const key of Object.keys(cfg)) {
-        if (!DEFAULT_COMMAND_KEY_SET.has(key)) {
-            fail(filename, `defaultCommand contains unknown key "${key}" (expected one of: ${DEFAULT_COMMAND_KEYS.join(', ')})`);
-        }
-    }
-    for (const key of [
-        'fix',
-        'merge',
-        'dedup',
-        'sort',
-        'check',
-        'analyze',
-        'typos',
-        'watch',
-    ]) {
+    assertKnownKeys(cfg, DEFAULT_COMMAND_KEYS, 'defaultCommand contains unknown key', filename);
+    for (const key of DEFAULT_COMMAND_BOOLEAN_KEYS) {
         if (key in cfg && typeof cfg[key] !== 'boolean') {
             fail(filename, `defaultCommand.${key} must be a boolean`);
         }
@@ -150,11 +140,7 @@ export function validateConfig(input, filename = CONFIG_FILENAME) {
         fail(filename, 'default export must be an object');
     }
     const cfg = input;
-    for (const key of Object.keys(cfg)) {
-        if (!KNOWN_KEY_SET.has(key)) {
-            fail(filename, `unknown key "${key}" (expected one of: ${KNOWN_KEYS.join(', ')})`);
-        }
-    }
+    assertKnownKeys(cfg, KNOWN_KEYS, 'unknown key', filename);
     if ('customTextTokens' in cfg)
         assertPxTokenMap(cfg.customTextTokens, 'customTextTokens', filename);
     if ('customSpacingTokens' in cfg)
@@ -183,7 +169,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

@@ -23,7 +23,7 @@ export type ScaleInconsistency = {
     property: string;
     values: ScaleValue[];
 };
-type RareScaleValue = {
+export type RareScaleValue = {
     property: string;
     value: string;
     className: string;
@@ -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

@@ -30,53 +30,6 @@ const POSITION_GROUP = new Set([
     'relative',
     'sticky',
 ]);
-const SIDE_MAP = {
-    p: ['t', 'b', 'l', 'r'],
-    m: ['t', 'b', 'l', 'r'],
-    border: ['t', 'b', 'l', 'r'],
-    inset: ['t', 'b', 'l', 'r'],
-    gap: ['t', 'b', 'l', 'r'],
-    'scroll-p': ['t', 'b', 'l', 'r'],
-    'scroll-m': ['t', 'b', 'l', 'r'],
-    px: ['l', 'r'],
-    mx: ['l', 'r'],
-    'border-x': ['l', 'r'],
-    'inset-x': ['l', 'r'],
-    'gap-x': ['l', 'r'],
-    'scroll-px': ['l', 'r'],
-    'scroll-mx': ['l', 'r'],
-    py: ['t', 'b'],
-    my: ['t', 'b'],
-    'border-y': ['t', 'b'],
-    'inset-y': ['t', 'b'],
-    'gap-y': ['t', 'b'],
-    'scroll-py': ['t', 'b'],
-    'scroll-my': ['t', 'b'],
-    pt: ['t'],
-    mt: ['t'],
-    'border-t': ['t'],
-    top: ['t'],
-    'scroll-pt': ['t'],
-    'scroll-mt': ['t'],
-    pb: ['b'],
-    mb: ['b'],
-    'border-b': ['b'],
-    bottom: ['b'],
-    'scroll-pb': ['b'],
-    'scroll-mb': ['b'],
-    pl: ['l'],
-    ml: ['l'],
-    'border-l': ['l'],
-    left: ['l'],
-    'scroll-pl': ['l'],
-    'scroll-ml': ['l'],
-    pr: ['r'],
-    mr: ['r'],
-    'border-r': ['r'],
-    right: ['r'],
-    'scroll-pr': ['r'],
-    'scroll-mr': ['r'],
-};
 const FAMILIES = [
     {
         kind: 'p',
@@ -160,6 +113,20 @@ const FAMILIES = [
         regex: /^(scroll-m|scroll-mx|scroll-my|scroll-mt|scroll-mb|scroll-ml|scroll-mr)-(.+)$/,
     },
 ];
+const SIDE_MAP = {};
+for (const f of FAMILIES) {
+    const entries = [
+        [f.full, ['t', 'b', 'l', 'r']],
+        [f.x, ['l', 'r']],
+        [f.y, ['t', 'b']],
+        [f.t, ['t']],
+        [f.b, ['b']],
+        [f.l, ['l']],
+        [f.r, ['r']],
+    ];
+    for (const [prefix, sides] of entries)
+        SIDE_MAP[prefix] ??= sides;
+}
 function parseBoxClass(cls) {
     for (const family of FAMILIES) {
         const m = cls.match(family.regex);
@@ -207,39 +174,27 @@ function collapseBox(box, f) {
     }
     return parts.join(' ');
 }
+const CORNER_MAP = {
+    '': ['tl', 'tr', 'bl', 'br'],
+    t: ['tl', 'tr'],
+    b: ['bl', 'br'],
+    l: ['tl', 'bl'],
+    r: ['tr', 'br'],
+    tl: ['tl'],
+    tr: ['tr'],
+    bl: ['bl'],
+    br: ['br'],
+};
 function parseRoundedCorner(cls) {
-    const sideM = cls.match(/^rounded-(tl|tr|bl|br|t|b|l|r)(?:-(.+))?$/);
-    if (sideM) {
-        const side = sideM[1];
-        const val = sideM[2] ?? '';
-        const c = {};
-        if (side === 't') {
-            c.tl = val;
-            c.tr = val;
-        }
-        else if (side === 'b') {
-            c.bl = val;
-            c.br = val;
-        }
-        else if (side === 'l') {
-            c.tl = val;
-            c.bl = val;
-        }
-        else if (side === 'r') {
-            c.tr = val;
-            c.br = val;
-        }
-        else {
-            c[side] = val;
-        }
-        return { corners: c };
-    }
-    const allM = cls.match(/^rounded(?:-(.+))?$/);
-    if (allM) {
-        const val = allM[1] ?? '';
-        return { corners: { tl: val, tr: val, bl: val, br: val } };
-    }
-    return null;
+    const m = cls.match(/^rounded-(tl|tr|bl|br|t|b|l|r)(?:-(.+))?$/) ??
+        cls.match(/^rounded()(?:-(.+))?$/);
+    if (!m)
+        return null;
+    const value = m[2] ?? '';
+    const corners = {};
+    for (const corner of CORNER_MAP[m[1]])
+        corners[corner] = value;
+    return corners;
 }
 function collapseCorners(c) {
     const { tl, tr, bl, br } = c;
@@ -300,137 +255,127 @@ 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
-    // by class name — or an intermediate override (e.g. md:block between flex and
-    // lg:flex) is missed and the restoring class is wrongly dropped.
-    const propertyKey = (base) => {
-        if (DISPLAY_GROUP.has(base))
-            return 'display';
-        if (POSITION_GROUP.has(base))
-            return 'position';
-        const dash = base.lastIndexOf('-');
-        return dash === -1 ? base : base.slice(0, dash);
-    };
     const entries = classes.map((cls, idx) => {
         for (const bp of RESPONSIVE_BREAKPOINTS) {
             const prefix = `${bp}:`;
             if (cls.startsWith(prefix) && !cls.slice(prefix.length).includes(':')) {
                 const base = cls.slice(prefix.length);
-                return { bp, base, key: propertyKey(base), idx };
+                return { bp, base, idx };
             }
         }
-        return { bp: '', base: cls, key: propertyKey(cls), idx };
+        return { bp: '', base: cls, idx };
     });
-    const groups = new Map();
-    for (const e of entries) {
-        const arr = groups.get(e.key);
-        if (arr)
-            arr.push(e);
-        else
-            groups.set(e.key, [e]);
-    }
+    // Unknown variants cannot be ordered against the standard breakpoints safely.
+    if (entries.some((entry) => entry.base.includes(':')))
+        return classes;
+    if (!entries.some((entry) => entry.bp !== ''))
+        return classes;
+    const sorted = [...entries].sort((a, b) => BP_RANK[a.bp] - BP_RANK[b.bp] || a.idx - b.idx);
     const toRemove = new Set();
-    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));
-        let prev = null;
-        for (const entry of sorted) {
-            if (entry.base === prev) {
-                toRemove.add(entry.idx);
-            }
-            else {
-                prev = entry.base;
-            }
-        }
+    let prev = null;
+    for (const entry of sorted) {
+        if (entry.base === prev)
+            toRemove.add(entry.idx);
+        else
+            prev = entry.base;
     }
     return classes.filter((_, i) => !toRemove.has(i));
 }
 // ─── Public API ───────────────────────────────────────────────────────────────
-function pushCollapsed(result, collapsed, classes) {
-    const original = [...new Set(classes)].join(' ');
-    result.push(...(collapsed === original ? original.split(' ') : collapsed.split(' ')));
+// Survivors keep their slot; new shorthands take the slot of the first token
+// they replace, so an unchanged group leaves the string byte-for-byte intact.
+function placeCollapsed(slots, classes, indices, collapsed) {
+    const firstIndex = new Map();
+    for (const i of indices) {
+        if (!firstIndex.has(classes[i]))
+            firstIndex.set(classes[i], i);
+    }
+    const kept = new Set();
+    const fresh = [];
+    for (const token of collapsed.split(' ')) {
+        const i = firstIndex.get(token);
+        if (i === undefined)
+            fresh.push(token);
+        else
+            kept.add(i);
+    }
+    for (const i of indices)
+        slots[i] = kept.has(i) ? [classes[i]] : [];
+    if (fresh.length === 0)
+        return;
+    const anchor = indices.find((i) => !kept.has(i)) ?? indices[0];
+    slots[anchor] = [...slots[anchor], ...fresh];
+}
+function keepLastOf(slots, indices) {
+    for (const i of indices.slice(0, -1))
+        slots[i] = [];
 }
 export function deduplicateClasses(classStr) {
-    let classes = classStr.split(/\s+/).filter(Boolean);
-    if (classes.length <= 1)
+    const original = classStr.split(/\s+/).filter(Boolean);
+    if (original.length <= 1)
         return classStr;
-    classes = collapseResponsiveCascade(classes);
-    let displayWinner = null;
-    let positionWinner = null;
+    const classes = collapseResponsiveCascade(original);
+    const slots = classes.map((cls) => [cls]);
+    const displayIndices = [];
+    const positionIndices = [];
     const seen = new Set();
-    const others = [];
     const boxGroups = new Map();
     const corners = { tl: null, tr: null, bl: null, br: null };
-    const cornersClasses = [];
-    for (const cls of classes) {
+    const cornerIndices = [];
+    classes.forEach((cls, idx) => {
         if (DISPLAY_GROUP.has(cls)) {
-            displayWinner = cls;
-            continue;
+            displayIndices.push(idx);
+            return;
         }
         if (POSITION_GROUP.has(cls)) {
-            positionWinner = cls;
-            continue;
+            positionIndices.push(idx);
+            return;
         }
         const parsed = parseBoxClass(cls);
         if (parsed) {
             const { family, sides } = parsed;
             let group = boxGroups.get(family.kind);
             if (!group) {
-                group = { family, box: { t: '', b: '', l: '', r: '' }, classes: [] };
+                group = { family, box: { t: '', b: '', l: '', r: '' }, indices: [] };
                 boxGroups.set(family.kind, group);
             }
-            group.classes.push(cls);
-            if (sides.t !== undefined)
-                group.box.t = sides.t;
-            if (sides.b !== undefined)
-                group.box.b = sides.b;
-            if (sides.l !== undefined)
-                group.box.l = sides.l;
-            if (sides.r !== undefined)
-                group.box.r = sides.r;
-            continue;
+            group.indices.push(idx);
+            Object.assign(group.box, sides);
+            return;
         }
-        const roundedParsed = parseRoundedCorner(cls);
-        if (roundedParsed) {
-            cornersClasses.push(cls);
-            const { corners: c } = roundedParsed;
-            if (c.tl !== undefined)
-                corners.tl = c.tl;
-            if (c.tr !== undefined)
-                corners.tr = c.tr;
-            if (c.bl !== undefined)
-                corners.bl = c.bl;
-            if (c.br !== undefined)
-                corners.br = c.br;
-            continue;
+        const roundedCorners = parseRoundedCorner(cls);
+        if (roundedCorners) {
+            cornerIndices.push(idx);
+            Object.assign(corners, roundedCorners);
+            return;
         }
-        if (!seen.has(cls)) {
+        if (seen.has(cls))
+            slots[idx] = [];
+        else
             seen.add(cls);
-            others.push(cls);
-        }
-    }
-    const result = [];
-    if (displayWinner)
-        result.push(displayWinner);
-    if (positionWinner)
-        result.push(positionWinner);
-    for (const { family, box, classes: groupClasses } of boxGroups.values()) {
-        if (groupClasses.length === 0)
-            continue;
-        pushCollapsed(result, collapseBox(box, family), groupClasses);
+    });
+    keepLastOf(slots, displayIndices);
+    keepLastOf(slots, positionIndices);
+    for (const { family, box, indices } of boxGroups.values()) {
+        placeCollapsed(slots, classes, indices, collapseBox(box, family));
     }
-    if (cornersClasses.length > 0) {
-        pushCollapsed(result, collapseCorners(corners), cornersClasses);
+    if (cornerIndices.length > 0) {
+        placeCollapsed(slots, classes, cornerIndices, collapseCorners(corners));
     }
-    result.push(...others);
-    return result.join(' ');
+    const result = slots.flat();
+    const unchanged = result.length === original.length &&
+        result.every((cls, i) => cls === original[i]);
+    return unchanged ? classStr : result.join(' ');
 }
 export function dedupeContent(content, opts = {}) {
     return replaceClassStrings(content, deduplicateClasses, {
@@ -439,4 +384,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