tailwind-canonical 0.6.0 → 0.7.1

package/dist/core/merger.js

@@ -26,20 +26,38 @@ function parseClassToken(token) {
         base: parts.at(-1) ?? token,
     };
 }
-function isLeadingClass(base) {
-    return /^!?leading-/.test(base);
-}
-function isArbitraryTextSize(base) {
-    return /^!?text-\[-?(?:\d+(?:\.\d+)?|\.\d+)(?:px|rem|em|ch|ex|lh|rlh|vw|vh|vmin|vmax|vi|vb|svw|lvw|dvw|svh|lvh|dvh)\]$/.test(base);
-}
-function customTextClassSet(customTextTokens) {
-    return new Set(Object.values(customTextTokens ?? {}).map((token) => `text-${token}`));
-}
+const RE_LEADING = /^!?leading-/;
+const RE_ARBITRARY_TEXT_SIZE = /^!?text-\[-?(?:\d+(?:\.\d+)?|\.\d+)(?:px|rem|em|ch|ex|lh|rlh|vw|vh|vmin|vmax|vi|vb|svw|lvw|dvw|svh|lvh|dvh)\]$/;
 function isUnsafeTextSize(base, customTextClasses) {
     const normalized = base.startsWith('!') ? base.slice(1) : base;
-    return customTextClasses.has(normalized) || isArbitraryTextSize(normalized);
+    return (customTextClasses.has(normalized) || RE_ARBITRARY_TEXT_SIZE.test(normalized));
+}
+/**
+ * Last `leading-*` class declared before `cls` in the original string that
+ * twMerge dropped, matching `cls`'s variant modifiers. Scans backwards from
+ * `cls`'s own position — a leading declared after it never applied to it.
+ */
+function lastLeadingBefore(originalClasses, cls, mergedTokens) {
+    // twMerge keeps the last occurrence of repeated class tokens. Use that
+    // occurrence when restoring its preceding leading utility.
+    let at = -1;
+    for (let i = originalClasses.length - 1; i >= 0; i -= 1) {
+        if (originalClasses[i].token === cls.token) {
+            at = i;
+            break;
+        }
+    }
+    for (let i = at - 1; i >= 0; i -= 1) {
+        const candidate = originalClasses[i];
+        if (RE_LEADING.test(candidate.base) &&
+            candidate.modifiers === cls.modifiers &&
+            !mergedTokens.has(candidate.token)) {
+            return candidate;
+        }
+    }
+    return undefined;
 }
-function restoreLeadingForUnsafeTextSizes(original, merged, opts) {
+function restoreLeadingForUnsafeTextSizes(original, merged, customTextClasses) {
     const originalClasses = original
         .split(/\s+/)
         .filter(Boolean)
@@ -49,34 +67,28 @@ function restoreLeadingForUnsafeTextSizes(original, merged, opts) {
         .filter(Boolean)
         .map(parseClassToken);
     const mergedTokens = new Set(mergedClasses.map(({ token }) => token));
-    const customTextClasses = customTextClassSet(opts.customTextTokens);
+    const keptLeadingModifiers = new Set(mergedClasses
+        .filter(({ base }) => RE_LEADING.test(base))
+        .map(({ modifiers }) => modifiers));
     const restored = [];
     for (const cls of mergedClasses) {
-        const leading = originalClasses
-            .slice(0, originalClasses.findIndex(({ token }) => token === cls.token))
-            .filter((candidate) => isLeadingClass(candidate.base) &&
-            candidate.modifiers === cls.modifiers &&
-            !mergedTokens.has(candidate.token))
-            .at(-1);
-        if (leading &&
-            isUnsafeTextSize(cls.base, customTextClasses) &&
-            !mergedClasses.some((candidate) => isLeadingClass(candidate.base) &&
-                candidate.modifiers === cls.modifiers)) {
-            restored.push(leading.token);
-            mergedTokens.add(leading.token);
+        if (isUnsafeTextSize(cls.base, customTextClasses) &&
+            !keptLeadingModifiers.has(cls.modifiers)) {
+            const leading = lastLeadingBefore(originalClasses, cls, mergedTokens);
+            if (leading) {
+                restored.push(leading.token);
+                mergedTokens.add(leading.token);
+            }
         }
         restored.push(cls.token);
     }
     return restored.join(' ');
 }
 export function mergeContent(content, twMerge, opts = {}) {
-    return replaceClassStrings(content, (classes) => {
-        const merged = twMerge(classes);
-        return restoreLeadingForUnsafeTextSizes(classes, merged, opts);
-    }, {
+    const customTextClasses = new Set(Object.values(opts.customTextTokens ?? {}).map((token) => `text-${token}`));
+    return replaceClassStrings(content, (classes) => restoreLeadingForUnsafeTextSizes(classes, twMerge(classes), customTextClasses), {
         ...opts,
         isSuppressed: makeLineSuppressor(content),
     });
 }
 export { mergeFile } from '../io/merger.js';
-//# sourceMappingURL=merger.js.map

package/dist/core/rules.d.ts

@@ -40,7 +40,8 @@ export type Config = {
     rareScaleMaxFiles?: number;
     rareScaleMaxCount?: number;
     defaultCommand?: DefaultCommandConfig;
+    /** Target Tailwind major. v3 restricts suggestions to its discrete scale. */
+    tailwindVersion?: 3 | 4;
 };
 export declare function suggestCanonical(cls: string, config?: Config): Suggestion | null;
 export {};
-//# sourceMappingURL=rules.d.ts.map

package/dist/core/rules.js

@@ -13,9 +13,7 @@ const TEXT_SIZE_MAP = {
     96: '8xl',
     128: '9xl',
 };
-const BUILT_IN_TEXT_PX = new Set([
-    12, 14, 16, 18, 20, 24, 30, 36, 48, 60, 72, 96, 128,
-]);
+const BUILT_IN_TEXT_PX = new Set(Object.keys(TEXT_SIZE_MAP).map(Number));
 const ROUNDED_MAP = {
     2: 'sm',
     4: 'sm',
@@ -102,6 +100,47 @@ const FRACTION_RE = new RegExp(`^(${FRACTION_PREFIXES.join('|')})-\\[(\\d+(?:\\.
 const OPACITY_SCALE = new Set([
     0, 5, 10, 20, 25, 30, 40, 50, 60, 70, 75, 80, 90, 95, 100,
 ]);
+/**
+ * Numeric spacing steps the ÷4 rule may emit that Tailwind v3 actually ships.
+ * v4 derives every step from `calc(var(--spacing) * n)`, so any integer works
+ * there; v3 ships a discrete scale and a class outside it generates no CSS.
+ * The ÷4 rule only ever yields integers, so v3's half steps are unreachable
+ * and absent here. Measured by compiling tailwindcss@3.3.7.
+ */
+const V3_SPACING_STEPS = new Set([
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44,
+    48, 52, 56, 60, 64, 72, 80, 96,
+]);
+/** No numeric spacing scale at all in v3.3, the documented floor. */
+const V3_UNSCALED_SPACING_PREFIXES = new Set(['size']);
+/** Only the zero step exists in v3.3; the scale itself arrived after 3.3. */
+const V3_ZERO_ONLY_SPACING_PREFIXES = new Set(['min-w', 'max-w', 'min-h']);
+const V3_INSET_FRACTIONS = ['1/2', '1/3', '2/3', '1/4', '3/4'];
+const V3_HEIGHT_FRACTIONS = [
+    ...V3_INSET_FRACTIONS,
+    '1/5',
+    '2/5',
+    '3/5',
+    '4/5',
+    '1/6',
+    '5/6',
+];
+/**
+ * Fractions each utility ships in v3.3 — the scale differs per utility, not
+ * just per family, so this is keyed on both. A prefix absent from this table
+ * has no fraction scale at all (`min-w`, `max-w`, `min-h`, `max-h`).
+ */
+const V3_FRACTIONS_BY_PREFIX = {
+    w: new Set([...V3_HEIGHT_FRACTIONS, '1/12', '11/12']),
+    h: new Set(V3_HEIGHT_FRACTIONS),
+    inset: new Set(V3_INSET_FRACTIONS),
+    top: new Set(V3_INSET_FRACTIONS),
+    left: new Set(V3_INSET_FRACTIONS),
+    right: new Set(V3_INSET_FRACTIONS),
+    bottom: new Set(V3_INSET_FRACTIONS),
+    'translate-x': new Set(V3_INSET_FRACTIONS),
+    'translate-y': new Set(V3_INSET_FRACTIONS),
+};
 function remToPx(rem) {
     const px = rem * 16;
     return Number.isInteger(px) ? px : null;
@@ -114,82 +153,72 @@ function isIgnored(cls, patterns) {
         return re.test(cls);
     });
 }
+/** True when the ÷4 result would be a class v3 never generates. */
+function isMissingInV3(prefix, step) {
+    if (V3_UNSCALED_SPACING_PREFIXES.has(prefix))
+        return true;
+    if (V3_ZERO_ONLY_SPACING_PREFIXES.has(prefix))
+        return step !== 0;
+    return !V3_SPACING_STEPS.has(step);
+}
+function textSuggestion(cls, px, textTokens) {
+    const token = textTokens[px];
+    if (!token)
+        return null;
+    return {
+        original: cls,
+        canonical: `text-${token}`,
+        isCustomToken: !BUILT_IN_TEXT_PX.has(px),
+    };
+}
+function spacingSuggestion(cls, prefix, px, spacingTokens, v3) {
+    if (spacingTokens[px]) {
+        return {
+            original: cls,
+            canonical: `${prefix}-${spacingTokens[px]}`,
+            isCustomToken: true,
+        };
+    }
+    if (px % 4 !== 0)
+        return null;
+    if (v3 && isMissingInV3(prefix, px / 4))
+        return null;
+    return {
+        original: cls,
+        canonical: `${prefix}-${px / 4}`,
+        isCustomToken: false,
+    };
+}
 export function suggestCanonical(cls, config = {}) {
     if (isIgnored(cls, config.ignorePatterns))
         return null;
     const textTokens = { ...TEXT_SIZE_MAP, ...config.customTextTokens };
     const spacingTokens = config.customSpacingTokens ?? {};
+    const v3 = config.tailwindVersion === 3;
     // text-[Npx]
     const textPxMatch = cls.match(/^text-\[(\d+)px\]$/);
     if (textPxMatch) {
-        const px = parseInt(textPxMatch[1], 10);
-        const token = textTokens[px];
-        if (!token)
-            return null;
-        return {
-            original: cls,
-            canonical: `text-${token}`,
-            isCustomToken: !BUILT_IN_TEXT_PX.has(px),
-        };
+        return textSuggestion(cls, parseInt(textPxMatch[1], 10), textTokens);
     }
     // text-[N.Nrem]
     const textRemMatch = cls.match(/^text-\[(\d+(?:\.\d+)?)rem\]$/);
     if (textRemMatch) {
         const px = remToPx(parseFloat(textRemMatch[1]));
-        if (px === null)
-            return null;
-        const token = textTokens[px];
-        if (!token)
-            return null;
-        return {
-            original: cls,
-            canonical: `text-${token}`,
-            isCustomToken: !BUILT_IN_TEXT_PX.has(px),
-        };
+        return px === null ? null : textSuggestion(cls, px, textTokens);
     }
     // spacing-[Npx]
     const spacingPxMatch = cls.match(SPACING_PX_RE);
     if (spacingPxMatch) {
-        const prefix = spacingPxMatch[1];
         const px = parseInt(spacingPxMatch[2], 10);
-        if (spacingTokens[px]) {
-            return {
-                original: cls,
-                canonical: `${prefix}-${spacingTokens[px]}`,
-                isCustomToken: true,
-            };
-        }
-        if (px % 4 === 0) {
-            return {
-                original: cls,
-                canonical: `${prefix}-${px / 4}`,
-                isCustomToken: false,
-            };
-        }
-        return null;
+        return spacingSuggestion(cls, spacingPxMatch[1], px, spacingTokens, v3);
     }
     // spacing-[N.Nrem]
     const spacingRemMatch = cls.match(SPACING_REM_RE);
     if (spacingRemMatch) {
-        const prefix = spacingRemMatch[1];
         const px = remToPx(parseFloat(spacingRemMatch[2]));
         if (px === null)
             return null;
-        if (spacingTokens[px]) {
-            return {
-                original: cls,
-                canonical: `${prefix}-${spacingTokens[px]}`,
-                isCustomToken: true,
-            };
-        }
-        if (px % 4 === 0) {
-            return {
-                original: cls,
-                canonical: `${prefix}-${px / 4}`,
-                isCustomToken: false,
-            };
-        }
-        return null;
+        return spacingSuggestion(cls, spacingRemMatch[1], px, spacingTokens, v3);
     }
     // w/h/inset/etc-[N.N%]
     const fractionMatch = cls.match(FRACTION_RE);
@@ -199,6 +228,8 @@ export function suggestCanonical(cls, config = {}) {
         const fraction = FRACTION_MAP[pct];
         if (!fraction)
             return null;
+        if (v3 && !V3_FRACTIONS_BY_PREFIX[prefix]?.has(fraction))
+            return null;
         return {
             original: cls,
             canonical: `${prefix}-${fraction}`,
@@ -213,9 +244,12 @@ export function suggestCanonical(cls, config = {}) {
         // equivalent to opacity-<N> (a percentage), so leave it untouched.
         if (raw > 1)
             return null;
-        const value = Math.round(raw * 100);
-        if (!OPACITY_SCALE.has(value))
+        const scaled = raw * 100;
+        const value = Math.round(scaled);
+        if (!(OPACITY_SCALE.has(value) &&
+            Math.abs(scaled - value) <= Number.EPSILON * 100)) {
             return null;
+        }
         return {
             original: cls,
             canonical: `opacity-${value}`,
@@ -238,4 +272,3 @@ export function suggestCanonical(cls, config = {}) {
     }
     return null;
 }
-//# sourceMappingURL=rules.js.map

package/dist/core/scanner.d.ts

@@ -7,4 +7,3 @@ export type ScanOptions = {
 export declare function isGlob(target: string): boolean;
 export declare function globToRegex(pattern: string): RegExp;
 export { resolveTargets, scanFiles } from '../io/scanner.js';
-//# sourceMappingURL=scanner.d.ts.map

package/dist/core/scanner.js

@@ -17,6 +17,15 @@ export const DEFAULT_IGNORE = [
 export function isGlob(target) {
     return target.includes('*') || target.includes('?') || target.includes('{');
 }
+function escapeRegex(text) {
+    return text.replace(/[.*+?^${}()|[\]\\/]/g, '\\$&');
+}
+function wildcardToRegex(text) {
+    return text
+        .split('*')
+        .map((part) => part.split('?').map(escapeRegex).join('[^/]'))
+        .join('[^/]*');
+}
 export function globToRegex(pattern) {
     let i = 0;
     const anchored = pattern.startsWith('/') || /^[A-Za-z]:/.test(pattern);
@@ -24,10 +33,14 @@ export function globToRegex(pattern) {
     while (i < pattern.length) {
         const c = pattern[i];
         if (c === '*' && pattern[i + 1] === '*') {
-            re += '.*';
             i += 2;
-            if (pattern[i] === '/')
+            if (pattern[i] === '/') {
+                re += '(?:[^/]+/)*';
                 i++;
+            }
+            else {
+                re += '.*';
+            }
         }
         else if (c === '*') {
             re += '[^/]*';
@@ -37,31 +50,20 @@ export function globToRegex(pattern) {
             re += '[^/]';
             i++;
         }
-        else if (c === '{') {
+        else if (c === '{' && pattern.indexOf('}', i) !== -1) {
             const close = pattern.indexOf('}', i);
-            if (close === -1) {
-                re += '\\{';
-                i++;
-            }
-            else {
-                const alts = pattern
-                    .slice(i + 1, close)
-                    .split(',')
-                    .map((a) => a.replace(/[.+^${}()|[\]\\]/g, '\\$&'));
-                re += `(?:${alts.join('|')})`;
-                i = close + 1;
-            }
-        }
-        else if (/[.+^${}()|[\]\\]/.test(c)) {
-            re += `\\${c}`;
-            i++;
+            const alts = pattern
+                .slice(i + 1, close)
+                .split(',')
+                .map(wildcardToRegex);
+            re += `(?:${alts.join('|')})`;
+            i = close + 1;
         }
         else {
-            re += c;
+            re += escapeRegex(c);
             i++;
         }
     }
     return new RegExp(`${re}$`);
 }
 export { resolveTargets, scanFiles } from '../io/scanner.js';
-//# sourceMappingURL=scanner.js.map

package/dist/core/sorter.d.ts

@@ -7,4 +7,3 @@ export declare function sortContent(content: string, opts?: ClassStringOpts, sor
     count: number;
 };
 export { sortFile } from '../io/sorter.js';
-//# sourceMappingURL=sorter.d.ts.map

package/dist/core/sorter.js

@@ -37,6 +37,7 @@ const TYPOGRAPHY_KEYWORDS = new Set([
     'antialiased',
     'subpixel-antialiased',
 ]);
+const RE_DARK_PRINT = /^(dark|print)$/;
 const TEXT_SIZES = /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl|left|center|right|justify|start|end)$/;
 const RE_LAYOUT = /^(overflow|overscroll|object|float|clear|isolation|box|columns)[-]/;
 const RE_INSET = /^(inset|top|right|bottom|left|z)[-]/;
@@ -98,7 +99,9 @@ function getCategory(cls) {
         return 'colors';
     if (base === 'shadow' ||
         base === 'blur' ||
-        ['grayscale', 'invert', 'sepia'].includes(base) ||
+        base === 'grayscale' ||
+        base === 'invert' ||
+        base === 'sepia' ||
         RE_EFFECTS.test(base))
         return 'effects';
     if (base === 'transition' || RE_TRANSITIONS.test(base))
@@ -128,15 +131,65 @@ function getVariantOrder(cls) {
     const segments = cls.slice(0, cls.lastIndexOf(':')).split(':');
     if (segments.some((s) => RE_BREAKPOINTS.test(s)))
         return 1;
-    if (segments.some((s) => /^(dark|print)$/.test(s)))
+    if (segments.some((s) => RE_DARK_PRINT.test(s)))
         return 2;
     return 3;
 }
-export function sortClasses(classStr, sortOrder) {
-    const classes = classStr.split(/\s+/).filter(Boolean);
-    if (classes.length <= 1)
-        return classStr;
-    const rank = buildRank(sortOrder?.length ? sortOrder : DEFAULT_SORT_ORDER);
+const RE_ARBITRARY = /\[[^\]]*\]/g;
+const RE_IMPLAUSIBLE_CLASS = /^:|:$|["'`{}?]|^[&|]+$/;
+function isPlausibleClass(token) {
+    return !RE_IMPLAUSIBLE_CLASS.test(token.replace(RE_ARBITRARY, '[]'));
+}
+function interpolationEnd(str, from) {
+    let depth = 0;
+    let quote = null;
+    for (let j = from + 1; j < str.length; j++) {
+        const ch = str[j];
+        if (quote) {
+            if (ch === '\\')
+                j++;
+            else if (ch === quote)
+                quote = null;
+        }
+        else if (ch === '"' || ch === "'" || ch === '`')
+            quote = ch;
+        else if (ch === '{')
+            depth++;
+        else if (ch === '}' && --depth === 0)
+            return j + 1;
+    }
+    return str.length;
+}
+function splitAtoms(str) {
+    const atoms = [];
+    let i = 0;
+    while (i < str.length) {
+        if (/\s/.test(str[i])) {
+            i++;
+            continue;
+        }
+        let j = i;
+        let interpolated = false;
+        while (j < str.length && !/\s/.test(str[j])) {
+            if (str.startsWith('${', j)) {
+                interpolated = true;
+                j = interpolationEnd(str, j);
+            }
+            else
+                j++;
+        }
+        const text = str.slice(i, j);
+        atoms.push({
+            text,
+            start: i,
+            end: j,
+            fixed: interpolated || !isPlausibleClass(text),
+        });
+        i = j;
+    }
+    return atoms;
+}
+function sortSegment(classes, rank) {
     return classes
         .map((cls, i) => ({
         cls,
@@ -153,8 +206,31 @@ export function sortClasses(classStr, sortOrder) {
             return cd;
         return a.i - b.i;
     })
-        .map((x) => x.cls)
-        .join(' ');
+        .map((x) => x.cls);
+}
+export function sortClasses(classStr, sortOrder) {
+    const atoms = splitAtoms(classStr);
+    if (atoms.length <= 1)
+        return classStr;
+    const rank = buildRank(sortOrder?.length ? sortOrder : DEFAULT_SORT_ORDER);
+    if (!atoms.some((a) => a.fixed))
+        return sortSegment(atoms.map((a) => a.text), rank).join(' ');
+    const texts = atoms.map((a) => a.text);
+    let start = 0;
+    for (let k = 0; k <= atoms.length; k++) {
+        if (k < atoms.length && !atoms[k].fixed)
+            continue;
+        const sorted = sortSegment(texts.slice(start, k), rank);
+        texts.splice(start, sorted.length, ...sorted);
+        start = k + 1;
+    }
+    let out = '';
+    let cursor = 0;
+    atoms.forEach((atom, k) => {
+        out += classStr.slice(cursor, atom.start) + texts[k];
+        cursor = atom.end;
+    });
+    return out + classStr.slice(cursor);
 }
 export function sortContent(content, opts = {}, sortOrder) {
     return replaceClassStrings(content, (s) => sortClasses(s, sortOrder), {
@@ -163,4 +239,3 @@ export function sortContent(content, opts = {}, sortOrder) {
     });
 }
 export { sortFile } from '../io/sorter.js';
-//# sourceMappingURL=sorter.js.map

package/dist/core/suppressions.d.ts

@@ -1,8 +1,6 @@
 export declare function getSuppressedLines(content: string): Set<number>;
 export declare function makeLineSuppressor(content: string): (line: number) => boolean;
-export declare function indexToLineCol(content: string, index: number): {
+export declare function createPositionLookup(content: string): (index: number) => {
     line: number;
     col: number;
 };
-export declare function lineAt(content: string, offset: number): number;
-//# sourceMappingURL=suppressions.d.ts.map

package/dist/core/suppressions.js

@@ -26,19 +26,22 @@ export function makeLineSuppressor(content) {
     const suppressed = getSuppressedLines(content);
     return (line) => suppressed.has(line);
 }
-export function indexToLineCol(content, index) {
-    let line = 1;
-    let lastNewline = -1;
-    const end = Math.min(index, content.length);
-    for (let i = 0; i < end; i++) {
-        if (content[i] === '\n') {
-            line++;
-            lastNewline = i;
-        }
+export function createPositionLookup(content) {
+    const lineStarts = [0];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === '\n')
+            lineStarts.push(i + 1);
     }
-    return { line, col: index - lastNewline };
-}
-export function lineAt(content, offset) {
-    return indexToLineCol(content, offset).line;
+    return (index) => {
+        let low = 0;
+        let high = lineStarts.length;
+        while (low + 1 < high) {
+            const mid = Math.floor((low + high) / 2);
+            if (lineStarts[mid] <= index)
+                low = mid;
+            else
+                high = mid;
+        }
+        return { line: low + 1, col: index - lineStarts[low] + 1 };
+    };
 }
-//# sourceMappingURL=suppressions.js.map

package/dist/core/typos.d.ts

@@ -11,4 +11,3 @@ export declare function detectTypo(cls: string, extraColors?: ReadonlySet<string
 } | null;
 export declare function analyzeTyposContent(filePath: string, content: string, config?: Config): TypoFinding[];
 export { analyzeTyposFile } from '../io/typos.js';
-//# sourceMappingURL=typos.d.ts.map

package/dist/core/typos.js

@@ -1,6 +1,6 @@
 import { extractClassStrings, SINGLE_CLASS_REGEX, toClassStringOpts, } from './class-strings.js';
 import { parseColorClass, TAILWIND_COLORS } from './lexicon.js';
-import { getSuppressedLines, indexToLineCol } from './suppressions.js';
+import { createPositionLookup, getSuppressedLines } from './suppressions.js';
 const MIN_COLOR_LEN = 3;
 function levenshtein(a, b) {
     const m = a.length;
@@ -45,6 +45,7 @@ export function detectTypo(cls, extraColors = new Set()) {
 export function analyzeTyposContent(filePath, content, config = {}) {
     const findings = [];
     const suppressed = getSuppressedLines(content);
+    const positionAt = createPositionLookup(content);
     const opts = toClassStringOpts(config);
     const extraColors = new Set(config.extraColors ?? []);
     for (const { value, start } of extractClassStrings(content, opts)) {
@@ -53,7 +54,7 @@ export function analyzeTyposContent(filePath, content, config = {}) {
             if (!typo)
                 continue;
             const index = start + (clsMatch.index ?? 0);
-            const { line, col } = indexToLineCol(content, index);
+            const { line, col } = positionAt(index);
             if (suppressed.has(line))
                 continue;
             findings.push({
@@ -68,4 +69,3 @@ export function analyzeTyposContent(filePath, content, config = {}) {
     return findings;
 }
 export { analyzeTyposFile } from '../io/typos.js';
-//# sourceMappingURL=typos.js.map

package/dist/eslint/plugin.d.ts

@@ -15,4 +15,3 @@ interface TailwindCanonicalPlugin {
 }
 declare const plugin: TailwindCanonicalPlugin;
 export default plugin;
-//# sourceMappingURL=plugin.d.ts.map