Skip to main content

tailwindcss_atomic/
atomic.rs

1use std::collections::{HashMap, HashSet};
2
3use lightningcss::declaration::DeclarationBlock;
4use lightningcss::rules::CssRule;
5use lightningcss::stylesheet::{ParserFlags, ParserOptions, PrinterOptions, StyleSheet};
6use lightningcss::traits::ToCss;
7
8use crate::classes::normalize_utility_class_name;
9use crate::stats::{compute_atomic_stats, AtomicStats};
10use crate::tailwind::looks_like_tailwind_utility;
11
12const TAILWIND_PSEUDO_ELEMENTS: &[&str] = &[
13    "::-webkit-input-placeholder",
14    "::placeholder",
15    "::file-selector-button",
16    "::marker",
17    "::backdrop",
18    "::first-line",
19    "::first-letter",
20    "::selection",
21];
22
23fn printer_options() -> PrinterOptions<'static> {
24    PrinterOptions {
25        minify: false,
26        ..PrinterOptions::default()
27    }
28}
29
30fn parser_options<'i>() -> ParserOptions<'i> {
31    ParserOptions {
32        filename: String::from("tailwindcss-atomic.css"),
33        flags: ParserFlags::NESTING,
34        error_recovery: true,
35        ..ParserOptions::default()
36    }
37}
38
39pub fn hash_string(input: &str) -> String {
40    let mut hash: u64 = 5381;
41    for byte in input.bytes() {
42        hash = ((hash << 5).wrapping_add(hash)).wrapping_add(byte as u64);
43    }
44    format!("_{:06x}", hash & 0xFFFFFF)
45}
46
47fn to_css<T: ToCss>(value: &T) -> String {
48    value.to_css_string(printer_options()).unwrap_or_default()
49}
50
51fn has_tailwind_variant_escape(selector: &str) -> bool {
52    selector.contains("\\:")
53}
54
55fn is_document_or_theme_root_selector(selector: &str) -> bool {
56    let sel = selector.trim();
57    sel.starts_with("html")
58        || sel.starts_with("body")
59        || sel.starts_with(":root")
60        || sel.contains("[data-theme")
61}
62
63fn is_tailwind_space_or_divide_selector(selector: &str) -> bool {
64    let sel = selector.trim();
65    let bytes = sel.as_bytes();
66    if bytes.first() != Some(&b'.') {
67        return false;
68    }
69    let mut class_end = 1;
70    while class_end < bytes.len() {
71        let b = bytes[class_end];
72        if b == b'\\' {
73            class_end = skip_css_escape(bytes, class_end);
74            continue;
75        }
76        if matches!(b, b' ' | b'>' | b'+' | b'~') {
77            break;
78        }
79        class_end += 1;
80    }
81    let rest = sel[class_end..].trim_start();
82    rest == "> :not([hidden]) ~ :not([hidden])" || rest == ">:not([hidden])~:not([hidden])"
83}
84
85fn has_component_pseudo_element(selector: &str) -> bool {
86    if has_tailwind_variant_escape(selector) {
87        return false;
88    }
89    // lightningcss prints `:before` / `:after`; source CSS often uses `::`.
90    if selector.contains(":before") || selector.contains(":after") {
91        return true;
92    }
93    if !selector.contains("::") {
94        return false;
95    }
96    let mut stripped = selector.to_string();
97    for pseudo in TAILWIND_PSEUDO_ELEMENTS {
98        stripped = stripped.replace(pseudo, "");
99    }
100    stripped.contains("::")
101}
102
103fn has_non_utility_combinator(selector: &str) -> bool {
104    if is_tailwind_space_or_divide_selector(selector) {
105        return false;
106    }
107    let mut normalized = String::new();
108    let bytes = selector.as_bytes();
109    let mut i = 0;
110    while i < bytes.len() {
111        if bytes[i] == b'\\' {
112            i = skip_css_escape(bytes, i);
113            continue;
114        }
115        if bytes[i] == b'(' {
116            normalized.push_str("()");
117            while i < bytes.len() && bytes[i] != b')' {
118                if bytes[i] == b'\\' {
119                    i = skip_css_escape(bytes, i);
120                    continue;
121                }
122                i += 1;
123            }
124            if i < bytes.len() {
125                i += 1;
126            }
127            continue;
128        }
129        normalized.push(bytes[i] as char);
130        i += 1;
131    }
132    normalized
133        .chars()
134        .any(|ch| matches!(ch, ' ' | '>' | '+' | '~'))
135}
136
137fn skip_css_escape(bytes: &[u8], i: usize) -> usize {
138    if i < bytes.len() && bytes[i] == b'\\' {
139        (i + 2).min(bytes.len())
140    } else {
141        i
142    }
143}
144
145fn is_class_name_terminator(b: u8) -> bool {
146    // Unescaped `[` starts an attribute selector (`.data-\[x\]\:flex[data-x]`),
147    // not an arbitrary value. Arbitrary `[…]` in class idents is escaped (`\[`).
148    matches!(
149        b,
150        b' ' | b'.' | b':' | b'#' | b'>' | b'+' | b'~' | b',' | b'['
151    )
152}
153
154/// Scan a CSS class ident after `.`. Escaped `\[` stays in the name
155/// (`.from-primary\/\[0\.05\]`); a raw `[` ends the ident so
156/// `[data-active=true]` remains a suffix on the selector.
157fn scan_class_name_end(bytes: &[u8], mut i: usize) -> usize {
158    while i < bytes.len() {
159        if bytes[i] == b'\\' {
160            i = skip_css_escape(bytes, i);
161            continue;
162        }
163        if is_class_name_terminator(bytes[i]) {
164            break;
165        }
166        i += 1;
167    }
168    i
169}
170
171fn count_unescaped_classes(selector: &str) -> usize {
172    let bytes = selector.as_bytes();
173    let mut count = 0;
174    let mut i = 0;
175    while i < bytes.len() {
176        if bytes[i] == b'\\' {
177            i = skip_css_escape(bytes, i);
178            continue;
179        }
180        if bytes[i] == b'.' {
181            count += 1;
182            i = scan_class_name_end(bytes, i + 1);
183            continue;
184        }
185        i += 1;
186    }
187    count
188}
189
190/// Split a selector list on top-level commas only.
191/// Escaped commas (`\,`), quoted strings and nested `()` / `[]` stay intact so
192/// Tailwind arbitrary values like `.transition-\[color\,box-shadow\]` remain one selector.
193fn split_comma_selectors(selector: &str) -> Vec<&str> {
194    let bytes = selector.as_bytes();
195    let mut parts = Vec::new();
196    let mut start = 0;
197    let mut i = 0;
198    let mut paren = 0i32;
199    let mut bracket = 0i32;
200    let mut quote: Option<u8> = None;
201
202    while i < bytes.len() {
203        let b = bytes[i];
204        if b == b'\\' {
205            i = skip_css_escape(bytes, i);
206            continue;
207        }
208        if let Some(q) = quote {
209            if b == q {
210                quote = None;
211            }
212            i += 1;
213            continue;
214        }
215        match b {
216            b'"' | b'\'' => {
217                quote = Some(b);
218                i += 1;
219            }
220            b'(' => {
221                paren += 1;
222                i += 1;
223            }
224            b')' => {
225                paren = paren.saturating_sub(1);
226                i += 1;
227            }
228            b'[' => {
229                bracket += 1;
230                i += 1;
231            }
232            b']' => {
233                bracket = bracket.saturating_sub(1);
234                i += 1;
235            }
236            b',' if paren == 0 && bracket == 0 => {
237                if let Some(part) = selector.get(start..i).map(str::trim).filter(|p| !p.is_empty())
238                {
239                    parts.push(part);
240                }
241                i += 1;
242                start = i;
243            }
244            _ => i += 1,
245        }
246    }
247
248    if let Some(part) = selector.get(start..).map(str::trim).filter(|p| !p.is_empty()) {
249        parts.push(part);
250    }
251    parts
252}
253
254fn looks_like_css_module_class(class_name: &str) -> bool {
255    if !class_name.contains("__") {
256        return false;
257    }
258    if class_name.contains('\\') || class_name.contains('[') || class_name.contains(':') {
259        return false;
260    }
261    true
262}
263
264fn class_token_is_tailwind_utility(selector: &str) -> bool {
265    match first_class_in_selector(selector) {
266        Some((_, raw)) => {
267            if looks_like_css_module_class(&raw) {
268                return false;
269            }
270            looks_like_tailwind_utility(&raw)
271        }
272        None => false,
273    }
274}
275
276fn is_single_utility_selector(selector: &str) -> bool {
277    let sel = selector.trim();
278    if !sel.contains('.') {
279        return false;
280    }
281    if is_tailwind_space_or_divide_selector(sel) {
282        return class_token_is_tailwind_utility(sel);
283    }
284    if !has_tailwind_variant_escape(sel) {
285        if is_document_or_theme_root_selector(sel) {
286            return false;
287        }
288        if has_component_pseudo_element(sel) {
289            return false;
290        }
291        if has_non_utility_combinator(sel) {
292            return false;
293        }
294        if count_unescaped_classes(sel) != 1 {
295            return false;
296        }
297    }
298    class_token_is_tailwind_utility(sel)
299}
300
301pub fn is_utility_selector(selector: &str) -> bool {
302    let parts = split_comma_selectors(selector);
303    !parts.is_empty() && parts.iter().all(|part| is_single_utility_selector(part))
304}
305
306fn has_theme_custom_properties(block: &DeclarationBlock<'_>) -> bool {
307    block.iter().any(|(prop, important)| {
308        let css = prop
309            .to_css_string(important, printer_options())
310            .unwrap_or_default();
311        let name = css.split(':').next().unwrap_or("").trim();
312        name.starts_with("--") && !name.starts_with("--tw-")
313    })
314}
315
316fn first_class_in_selector(selector: &str) -> Option<(usize, String)> {
317    let bytes = selector.as_bytes();
318    let mut i = 0;
319    while i < bytes.len() {
320        if bytes[i] == b'\\' {
321            i = skip_css_escape(bytes, i);
322            continue;
323        }
324        if bytes[i] == b'.' {
325            let start = i;
326            let class_start = i + 1;
327            i = scan_class_name_end(bytes, class_start);
328            let raw = selector.get(class_start..i.min(selector.len()))?;
329            if raw.is_empty() {
330                return None;
331            }
332            return Some((start, raw.to_string()));
333        }
334        i += 1;
335    }
336    None
337}
338
339fn replace_first_class(selector: &str, new_class: &str) -> String {
340    if let Some((dot_at, raw)) = first_class_in_selector(selector) {
341        let rest_at = dot_at.saturating_add(1).saturating_add(raw.len());
342        let prefix = selector.get(..dot_at).unwrap_or("");
343        let suffix = selector.get(rest_at..).unwrap_or("");
344        let mut out = String::with_capacity(prefix.len() + new_class.len() + suffix.len() + 1);
345        out.push_str(prefix);
346        out.push('.');
347        out.push_str(new_class);
348        out.push_str(suffix);
349        return out;
350    }
351    format!(".{new_class}")
352}
353
354fn collect_decls(block: &DeclarationBlock<'_>) -> Vec<String> {
355    let mut collected = Vec::new();
356    for (prop, important) in block.iter() {
357        if let Ok(css) = prop.to_css_string(important, printer_options()) {
358            if !css.is_empty() {
359                collected.push(css);
360            }
361        }
362    }
363    collected
364}
365
366fn wrap_at_rule(kind: &str, prelude: &str, inner: &str) -> String {
367    if inner.trim().is_empty() {
368        return String::new();
369    }
370    if prelude.is_empty() {
371        format!("@{kind} {{\n{inner}\n}}\n")
372    } else {
373        format!("@{kind} {prelude} {{\n{inner}\n}}\n")
374    }
375}
376
377fn resolve_nested_selector(parent: Option<&str>, nested: &str) -> String {
378    let nested = nested.trim();
379    let Some(parent) = parent.map(str::trim).filter(|sel| !sel.is_empty()) else {
380        return nested.to_string();
381    };
382    if nested.is_empty() || nested == "&" {
383        return parent.to_string();
384    }
385    if nested.contains('&') {
386        return nested.replace('&', parent);
387    }
388    if nested.starts_with(':') || nested.starts_with('[') {
389        return format!("{parent}{nested}");
390    }
391    nested.to_string()
392}
393
394fn has_declarations(block: &DeclarationBlock<'_>) -> bool {
395    block.iter().next().is_some()
396}
397
398struct EmitCtx<'a> {
399    class_map: &'a mut HashMap<String, Vec<String>>,
400    seen: &'a mut HashSet<String>,
401    component_classes: &'a HashSet<String>,
402    changed: bool,
403}
404
405fn collect_component_classes(rules: &[CssRule<'_>], out: &mut HashSet<String>) {
406    for rule in rules {
407        match rule {
408            CssRule::Style(style) => {
409                let selector = to_css(&style.selectors);
410                if has_component_pseudo_element(&selector) {
411                    if let Some((_, raw)) = first_class_in_selector(&selector) {
412                        let name = normalize_utility_class_name(&raw);
413                        if !name.is_empty() {
414                            out.insert(name);
415                        }
416                    }
417                }
418                collect_component_classes(&style.rules.0, out);
419            }
420            CssRule::Media(media) => collect_component_classes(&media.rules.0, out),
421            CssRule::Supports(supports) => collect_component_classes(&supports.rules.0, out),
422            CssRule::Container(container) => collect_component_classes(&container.rules.0, out),
423            CssRule::LayerBlock(layer) => collect_component_classes(&layer.rules.0, out),
424            CssRule::StartingStyle(starting) => collect_component_classes(&starting.rules.0, out),
425            _ => {}
426        }
427    }
428}
429
430fn emit_style_rule(
431    selector: &str,
432    block: &DeclarationBlock<'_>,
433    nested_empty: bool,
434    ctx: &mut EmitCtx<'_>,
435) -> String {
436    if !nested_empty || has_theme_custom_properties(block) || !is_utility_selector(selector) {
437        return String::new();
438    }
439
440    let Some((_, raw_class)) = first_class_in_selector(selector) else {
441        return String::new();
442    };
443    let original = normalize_utility_class_name(&raw_class);
444    if original.is_empty() || ctx.component_classes.contains(&original) {
445        return String::new();
446    }
447
448    let decls = collect_decls(block);
449    if decls.is_empty() {
450        return String::new();
451    }
452
453    let mut hashes = Vec::new();
454    let mut css = String::new();
455    for decl in decls {
456        let hash = hash_string(&format!("{original}\0{decl}"));
457        let next_selector = replace_first_class(selector, &hash);
458        let rule = format!("{next_selector} {{ {decl} }}");
459        hashes.push(hash);
460        if ctx.seen.insert(rule.clone()) {
461            css.push_str(&rule);
462            css.push('\n');
463        }
464    }
465
466    if hashes.is_empty() {
467        return String::new();
468    }
469
470    let entry = ctx.class_map.entry(original).or_default();
471    for hash in hashes {
472        if !entry.contains(&hash) {
473            entry.push(hash);
474        }
475    }
476    ctx.changed = true;
477    css
478}
479
480fn emit_at_rule_or_original(
481    kind: &str,
482    prelude: &str,
483    inner: String,
484    original: &CssRule<'_>,
485    out: &mut String,
486) {
487    if inner.trim().is_empty() {
488        out.push_str(&to_css(original));
489        out.push('\n');
490        return;
491    }
492    out.push_str(&wrap_at_rule(kind, prelude, &inner));
493}
494
495fn emit_rules(
496    rules: &[CssRule<'_>],
497    parent_selector: Option<&str>,
498    ctx: &mut EmitCtx<'_>,
499) -> String {
500    let mut out = String::new();
501    for rule in rules {
502        match rule {
503            CssRule::LayerBlock(layer) => {
504                out.push_str(&emit_rules(&layer.rules.0, parent_selector, ctx));
505            }
506            CssRule::LayerStatement(_) => {}
507            CssRule::Media(media) => {
508                let inner = emit_rules(&media.rules.0, parent_selector, ctx);
509                emit_at_rule_or_original("media", &to_css(&media.query), inner, rule, &mut out);
510            }
511            CssRule::Supports(supports) => {
512                let inner = emit_rules(&supports.rules.0, parent_selector, ctx);
513                emit_at_rule_or_original(
514                    "supports",
515                    &to_css(&supports.condition),
516                    inner,
517                    rule,
518                    &mut out,
519                );
520            }
521            CssRule::Container(container) => {
522                let prelude = match (&container.name, &container.condition) {
523                    (Some(name), Some(condition)) => {
524                        format!("{} {}", to_css(name), to_css(condition))
525                    }
526                    (Some(name), None) => to_css(name),
527                    (None, Some(condition)) => to_css(condition),
528                    (None, None) => String::new(),
529                };
530                let inner = emit_rules(&container.rules.0, parent_selector, ctx);
531                emit_at_rule_or_original("container", prelude.trim(), inner, rule, &mut out);
532            }
533            CssRule::StartingStyle(starting) => {
534                let inner = emit_rules(&starting.rules.0, parent_selector, ctx);
535                emit_at_rule_or_original("starting-style", "", inner, rule, &mut out);
536            }
537            CssRule::NestedDeclarations(decls) => {
538                if let Some(selector) = parent_selector {
539                    let atomic = emit_style_rule(selector, &decls.declarations, true, ctx);
540                    if atomic.is_empty() {
541                        out.push_str(&to_css(rule));
542                        out.push('\n');
543                    } else {
544                        out.push_str(&atomic);
545                    }
546                } else {
547                    out.push_str(&to_css(rule));
548                    out.push('\n');
549                }
550            }
551            CssRule::Style(style) => {
552                let raw_selector = to_css(&style.selectors);
553                let selector = resolve_nested_selector(parent_selector, &raw_selector);
554                let nested_empty = style.rules.0.is_empty();
555                let theme_tokens = has_theme_custom_properties(&style.declarations);
556                let utility = is_utility_selector(&selector)
557                    && first_class_in_selector(&selector)
558                        .map(|(_, raw)| {
559                            !ctx.component_classes
560                                .contains(&normalize_utility_class_name(&raw))
561                        })
562                        .unwrap_or(true);
563
564                // Skins / componentes con anidación: no desanidar.
565                if (!utility || theme_tokens) && !nested_empty {
566                    out.push_str(&to_css(style));
567                    out.push('\n');
568                    continue;
569                }
570
571                let mut emitted = String::new();
572                if has_declarations(&style.declarations) {
573                    emitted.push_str(&emit_style_rule(
574                        &selector,
575                        &style.declarations,
576                        true,
577                        ctx,
578                    ));
579                }
580                if !nested_empty {
581                    // Tailwind v4: `.lg\:flex { @media { display: flex } }` y `&:hover`.
582                    emitted.push_str(&emit_rules(&style.rules.0, Some(&selector), ctx));
583                }
584
585                if !emitted.is_empty() {
586                    out.push_str(&emitted);
587                } else {
588                    out.push_str(&to_css(style));
589                    out.push('\n');
590                }
591            }
592            CssRule::Ignored => {}
593            other => {
594                out.push_str(&to_css(other));
595                out.push('\n');
596            }
597        }
598    }
599    out
600}
601
602pub struct AtomicOutput {
603    pub class_map: HashMap<String, String>,
604    pub css: String,
605    pub css_rules: Vec<String>,
606    pub changed: bool,
607    pub stats: AtomicStats,
608}
609
610fn elapsed_micros(started: Option<std::time::Instant>) -> u64 {
611    started
612        .map(|start| start.elapsed().as_micros().min(u128::from(u64::MAX)) as u64)
613        .unwrap_or(0)
614}
615
616pub fn atomicize_stylesheet(raw_css: &str) -> Result<AtomicOutput, String> {
617    // Instant panics on some wasm32 targets; the JS plugin times WASM calls itself.
618    let started = if cfg!(target_arch = "wasm32") {
619        None
620    } else {
621        Some(std::time::Instant::now())
622    };
623    let stylesheet = StyleSheet::parse(raw_css, parser_options())
624        .map_err(|error| format!("Error parseando CSS: {error:?}"))?;
625
626    let mut class_lists: HashMap<String, Vec<String>> = HashMap::new();
627    let mut seen = HashSet::new();
628    let mut component_classes = HashSet::new();
629    collect_component_classes(&stylesheet.rules.0, &mut component_classes);
630    let mut ctx = EmitCtx {
631        class_map: &mut class_lists,
632        seen: &mut seen,
633        component_classes: &component_classes,
634        changed: false,
635    };
636    let css = emit_rules(&stylesheet.rules.0, None, &mut ctx);
637    let changed = ctx.changed;
638
639    let css_rules: Vec<String> = css
640        .lines()
641        .map(str::trim)
642        .filter(|line| line.starts_with("._") || line.contains("._"))
643        .filter(|line| line.contains('{'))
644        .map(ToString::to_string)
645        .collect();
646
647    let class_map = class_lists
648        .into_iter()
649        .map(|(key, hashes)| {
650            let mut unique = Vec::new();
651            for hash in hashes {
652                if !unique.contains(&hash) {
653                    unique.push(hash);
654                }
655            }
656            (key, unique.join(" "))
657        })
658        .collect();
659
660    let elapsed_us = elapsed_micros(started);
661    let stats = compute_atomic_stats(raw_css, &class_map, &css, changed, elapsed_us);
662
663    Ok(AtomicOutput {
664        class_map,
665        css,
666        css_rules,
667        changed,
668        stats,
669    })
670}
671
672#[cfg(test)]
673mod tests {
674    use super::*;
675
676    #[test]
677    fn atomicizes_bare_rounded() {
678        let out = atomicize_stylesheet(
679            ".rounded { border-radius: 0.25rem } .flex { display: flex }",
680        )
681        .unwrap();
682        assert!(out.class_map.get("rounded").is_some(), "css={}", out.css);
683        assert!(out.class_map.get("flex").is_some());
684        assert!(!out.css.contains(".rounded {"));
685        assert!(!out.css.contains(".flex {"));
686    }
687
688    #[test]
689    fn keeps_hover_on_the_selector() {
690        let out =
691            atomicize_stylesheet(".hover\\:bg-red-500:hover { background-color: red }").unwrap();
692        let hashed = out.class_map.get("hover:bg-red-500").expect("mapped");
693        assert!(out.css.contains(&format!(".{hashed}:hover")));
694        assert!(!out.css.contains(".hover\\:bg-red-500"));
695    }
696
697    #[test]
698    fn atomicizes_data_and_aria_attribute_variants() {
699        let out = atomicize_stylesheet(
700            r#"
701.data-\[active\=true\]\:font-medium[data-active=true] {
702  --tw-font-weight: var(--font-weight-medium);
703  font-weight: var(--font-weight-medium);
704}
705.data-\[state\=open\]\:flex[data-state=open] { display: flex }
706.aria-selected\:bg-red-500[aria-selected="true"] { background-color: red }
707.open\:hidden[open] { display: none }
708.flex { display: flex }
709"#,
710        )
711        .unwrap();
712
713        let data_font = out
714            .class_map
715            .get("data-[active=true]:font-medium")
716            .expect("data-[active=true]:font-medium");
717        let data_flex = out
718            .class_map
719            .get("data-[state=open]:flex")
720            .expect("data-[state=open]:flex");
721        assert!(out.class_map.get("aria-selected:bg-red-500").is_some());
722        assert!(out.class_map.get("open:hidden").is_some());
723        assert!(out.class_map.get("flex").is_some());
724
725        let font_hash = data_font.split_whitespace().next().expect("hash");
726        let flex_hash = data_flex.split_whitespace().next().expect("hash");
727        assert!(
728            out.css.contains(&format!(".{font_hash}[data-active=true]"))
729                || out.css.contains(&format!(".{font_hash}[data-active=\"true\"]")),
730            "expected hashed data-active suffix, css={}",
731            out.css
732        );
733        assert!(
734            out.css.contains(&format!(".{flex_hash}[data-state=open]"))
735                || out.css.contains(&format!(".{flex_hash}[data-state=\"open\"]")),
736            "expected hashed data-state suffix, css={}",
737            out.css
738        );
739        assert!(!out.css.contains(".data-\\[active"));
740        assert!(!out.css.contains(".data-\\[state"));
741
742        let rewritten = crate::rewrite_class_string(
743            "data-[active=true]:font-medium flex data-[state=open]:flex",
744            &out.class_map,
745        );
746        assert!(rewritten.contains(font_hash));
747        assert!(rewritten.contains(flex_hash));
748        assert!(!rewritten.contains("data-[active=true]:font-medium"));
749        assert!(!rewritten.contains("data-[state=open]:flex"));
750    }
751
752    #[test]
753    fn keeps_space_combinators() {
754        let out = atomicize_stylesheet(
755            ".space-y-4 > :not([hidden]) ~ :not([hidden]) { margin-top: 1rem }",
756        )
757        .unwrap();
758        let hashed = out.class_map.get("space-y-4").expect("mapped");
759        assert!(
760            out.css
761                .contains(&format!(".{hashed} > :not([hidden]) ~ :not([hidden])"))
762        );
763    }
764
765    #[test]
766    fn does_not_atomicize_css_module_locals() {
767        let out = atomicize_stylesheet(
768            ".Nexi_svg__def34 { display: block; width: 100% } .flex { display: flex }",
769        )
770        .unwrap();
771        assert!(out.css.contains(".Nexi_svg__def34"));
772        assert!(out.css.contains("display: block"));
773        assert!(out.class_map.get("Nexi_svg__def34").is_none());
774        assert!(out.class_map.get("flex").is_some());
775        assert!(!out.css.contains(".flex"));
776    }
777
778    #[test]
779    fn still_atomicizes_arbitrary_values_that_contain_underscores() {
780        let out = atomicize_stylesheet(".w-\\[1fr__2fr\\] { width: 1fr }").unwrap();
781        assert!(out.changed);
782        assert!(out.class_map.len() >= 1);
783        assert!(!out.css.contains("1fr__2fr") || out.css.contains("._"));
784    }
785
786    #[test]
787    fn does_not_atomicize_theme_tokens() {
788        let out = atomicize_stylesheet(
789            ".pokerenchile { --color-red-600: #bc0000 } .flex { display: flex }",
790        )
791        .unwrap();
792        assert!(out.css.contains(".pokerenchile"));
793        assert!(out.class_map.get("pokerenchile").is_none());
794        assert!(out.class_map.get("flex").is_some());
795    }
796
797    #[test]
798    fn keeps_responsive_variants_inside_media() {
799        let out = atomicize_stylesheet(
800            ".top-0 { top: 0 } @media (min-width: 640px) { .sm\\:top-0 { top: 0 } }",
801        )
802        .unwrap();
803        let base = out.class_map.get("top-0").expect("base");
804        let sm = out.class_map.get("sm:top-0").expect("sm");
805        assert_ne!(base, sm);
806        assert!(out.css.contains("@media"));
807        assert!(out.css.contains(&format!(".{sm}")));
808    }
809
810    #[test]
811    fn atomicizes_tailwind_v4_nested_breakpoint_variants() {
812        let out = atomicize_stylesheet(
813            r#"
814.hidden { display: none }
815.items-center { align-items: center }
816.gap-8 { gap: 2rem }
817.lg\:flex {
818  @media (width >= 64rem) {
819    display: flex;
820  }
821}
822"#,
823        )
824        .unwrap();
825
826        let hidden = out.class_map.get("hidden").expect("hidden");
827        let lg_flex = out.class_map.get("lg:flex").expect("lg:flex");
828        assert_ne!(hidden, lg_flex);
829        assert!(out.css.contains("@media"));
830        assert!(out.css.contains(&format!(".{lg_flex}")));
831        assert!(out.css.contains("display: flex"));
832        assert!(!out.css.contains(".lg\\:flex"));
833        assert!(!out.css.contains(".hidden {"));
834    }
835
836    #[test]
837    fn atomicizes_tailwind_v4_nested_hover() {
838        let out = atomicize_stylesheet(
839            r#".hover\:bg-red-500 { &:hover { background-color: red; } }"#,
840        )
841        .unwrap();
842        let hashed = out.class_map.get("hover:bg-red-500").expect("hover");
843        assert!(out.css.contains(&format!(".{hashed}:hover")));
844        assert!(!out.css.contains(".hover\\:bg-red-500"));
845    }
846
847    #[test]
848    fn atomicizes_before_and_after_pseudo_elements() {
849        let out = atomicize_stylesheet(
850            r#"
851.before\:block::before { content: var(--tw-content); display: block }
852.after\:content-\[\'\'\]::after { content: var(--tw-content); content: "" }
853.before\:absolute { &::before { content: var(--tw-content); position: absolute } }
854.after\:inset-0 { &::after { content: var(--tw-content); inset: 0px } }
855"#,
856        )
857        .unwrap();
858
859        let first_hash = |key: &str| {
860            out.class_map
861                .get(key)
862                .expect(key)
863                .split_whitespace()
864                .next()
865                .expect("hash")
866        };
867
868        let before_block = first_hash("before:block");
869        let after_content = first_hash("after:content-['']");
870        let before_abs = first_hash("before:absolute");
871        let after_inset = first_hash("after:inset-0");
872
873        assert!(
874            out.css.contains(&format!(".{before_block}:before")),
875            "flat before:block css: {}",
876            out.css
877        );
878        assert!(
879            out.css.contains(&format!(".{after_content}:after")),
880            "flat after:content css: {}",
881            out.css
882        );
883        assert!(
884            out.css.contains(&format!(".{before_abs}:before")),
885            "nested before:absolute css: {}",
886            out.css
887        );
888        assert!(
889            out.css.contains(&format!(".{after_inset}:after")),
890            "nested after:inset-0 css: {}",
891            out.css
892        );
893        assert!(!out.css.contains(".before\\:block"));
894        assert!(!out.css.contains(".after\\:content-"));
895        assert!(!out.css.contains(".before\\:absolute"));
896    }
897
898    #[test]
899    fn atomicizes_nested_lg_hover_flex() {
900        let out = atomicize_stylesheet(
901            r#"
902.lg\:hover\:flex {
903  @media (width >= 64rem) {
904    &:hover {
905      display: flex;
906    }
907  }
908}
909"#,
910        )
911        .unwrap();
912        let hashed = out.class_map.get("lg:hover:flex").expect("lg:hover:flex");
913        assert!(out.css.contains("@media"));
914        assert!(out.css.contains(&format!(".{hashed}:hover")));
915        assert!(out.css.contains("display: flex"));
916    }
917
918    #[test]
919    fn atomicizes_lg_flex_inside_media_range_query() {
920        let out = atomicize_stylesheet(
921            r#"
922.hidden { display: none }
923@media (width >= 64rem) {
924  .lg\:flex { display: flex }
925}
926"#,
927        )
928        .unwrap();
929
930        let lg_flex = out.class_map.get("lg:flex").expect("lg:flex");
931        assert!(out.css.contains("@media"));
932        assert!(out.css.contains(&format!(".{lg_flex}")));
933        assert!(out.css.contains("display: flex"));
934    }
935
936    #[test]
937    fn flattens_layers() {
938        let out = atomicize_stylesheet("@layer utilities { .flex { display: flex } }").unwrap();
939        assert!(!out.css.contains("@layer"));
940        assert!(out.class_map.get("flex").is_some());
941    }
942
943    #[test]
944    fn preserves_theme_inline_custom_variant_and_oklch() {
945        let out = atomicize_stylesheet(
946            r#"
947@custom-variant dark (&:is(.dark *));
948@theme inline {
949  --color-background: var(--background);
950  --color-primary: var(--primary);
951}
952:root {
953  --background: oklch(1 0 0);
954  --primary: oklch(0.21 0.006 285.885);
955}
956.dark {
957  --background: oklch(0.141 0.005 285.823);
958  --primary: oklch(0.92 0.004 286.32);
959}
960.bg-background { background-color: var(--background); }
961.bg-primary { background-color: var(--primary); }
962.flex { display: flex; }
963"#,
964        )
965        .unwrap();
966
967        assert!(out.css.contains("@theme inline"));
968        assert!(out.css.contains("--color-background: var(--background)"));
969        assert!(out.css.contains("@custom-variant dark"));
970        assert!(out.css.contains(":root"));
971        assert!(out.css.contains("oklch"));
972        assert!(out.css.contains(".dark"));
973        assert!(out.class_map.get("flex").is_some());
974        assert!(out.class_map.get("bg-background").is_some());
975        assert!(out.class_map.get("dark").is_none());
976    }
977
978    #[test]
979    fn escaped_commas_in_arbitrary_values_do_not_panic() {
980        let cases = [
981            (".flex{display:flex}", "flex"),
982            (".w-\\[calc\\(100px\\)\\]{width:calc(100px)}", "w-[calc(100px)]"),
983            (".\\[color\\:red\\]{color:red}", "[color:red]"),
984            (
985                ".transition-\\[color\\,box-shadow\\]{transition-property:color,box-shadow}",
986                "transition-[color,box-shadow]",
987            ),
988            (
989                ".grid-cols-\\[repeat\\(auto-fill\\,minmax\\(220px\\,1fr\\)\\)\\]{grid-template-columns:repeat(auto-fill,minmax(220px,1fr))}",
990                "grid-cols-[repeat(auto-fill,minmax(220px,1fr))]",
991            ),
992            (
993                ".\\[transition-timing-function\\:cubic-bezier\\(0\\.34\\,1\\.56\\,0\\.64\\,1\\)\\]{transition-timing-function:cubic-bezier(0.34,1.56,0.64,1)}",
994                "[transition-timing-function:cubic-bezier(0.34,1.56,0.64,1)]",
995            ),
996            (
997                ".sm\\:grid-cols-\\[3rem_minmax\\(0\\,1fr\\)_7rem\\]{grid-template-columns:3rem minmax(0,1fr) 7rem}",
998                "sm:grid-cols-[3rem_minmax(0,1fr)_7rem]",
999            ),
1000            (
1001                ".\\[\\&\\:hover\\>svg\\]\\:drop-shadow-\\[0_0_6px_rgba\\(250\\,204\\,21\\,0\\.4\\)\\]{filter:drop-shadow(0 0 6px rgba(250,204,21,.4))}",
1002                "[&:hover>svg]:drop-shadow-[0_0_6px_rgba(250,204,21,0.4)]",
1003            ),
1004        ];
1005        for (css, key) in cases {
1006            let out = atomicize_stylesheet(css).unwrap_or_else(|e| panic!("failed {css}: {e}"));
1007            assert!(
1008                out.class_map.contains_key(key),
1009                "missing {key} in {:?} for {css}",
1010                out.class_map.keys().collect::<Vec<_>>()
1011            );
1012            assert!(out.changed, "expected change for {css}");
1013        }
1014
1015        let custom = atomicize_stylesheet(".a\\,b{color:red}").unwrap();
1016        assert!(
1017            custom.class_map.get("a,b").is_none(),
1018            "escaped-comma custom class must not be hashed"
1019        );
1020        assert!(custom.css.contains(".a\\,b") || custom.css.contains("a\\,b"));
1021    }
1022
1023    #[test]
1024    fn preserves_custom_hyphenated_component_classes() {
1025        let out = atomicize_stylesheet(
1026            r#"
1027.header-signin { color: red }
1028.btn-notch { display: flex }
1029.eye-line { width: 1px }
1030.flex { display: flex }
1031.p-4 { padding: 1rem }
1032.items-center { align-items: center }
1033.bg-revamp-primary-default { background-color: var(--x) }
1034.before\:content-\[\'\'\]::before { content: var(--tw-content); content: "" }
1035"#,
1036        )
1037        .unwrap();
1038
1039        assert!(out.css.contains(".header-signin"));
1040        assert!(out.css.contains(".btn-notch"));
1041        assert!(out.css.contains(".eye-line"));
1042        assert!(out.class_map.get("header-signin").is_none());
1043        assert!(out.class_map.get("btn-notch").is_none());
1044        assert!(out.class_map.get("eye-line").is_none());
1045
1046        assert!(out.class_map.get("flex").is_some());
1047        assert!(out.class_map.get("p-4").is_some());
1048        assert!(out.class_map.get("items-center").is_some());
1049        assert!(out.class_map.get("bg-revamp-primary-default").is_some());
1050        assert!(out.class_map.get("before:content-['']").is_some());
1051        assert!(!out.css.contains(".flex {"));
1052        assert!(!out.css.contains(".p-4 {"));
1053    }
1054
1055    #[test]
1056    fn preserves_component_base_when_pseudo_elements_exist() {
1057        let out = atomicize_stylesheet(
1058            r#"
1059.header-signin {
1060  position: relative;
1061  isolation: isolate;
1062  background-color: var(--primary);
1063}
1064.header-signin::before {
1065  content: "";
1066  position: absolute;
1067}
1068.header-signin::after {
1069  content: "";
1070}
1071.flex { display: flex }
1072"#,
1073        )
1074        .unwrap();
1075
1076        assert!(out.css.contains(".header-signin"));
1077        assert!(out.css.contains(".header-signin:before") || out.css.contains(".header-signin::before"));
1078        assert!(out.class_map.get("header-signin").is_none());
1079        assert!(out.class_map.get("flex").is_some());
1080        assert!(!out.css.contains(".flex {"));
1081    }
1082
1083    #[test]
1084    fn atomicizes_supports_color_mix_arbitrary_opacity() {
1085        let out = atomicize_stylesheet(
1086            r#"
1087@supports (color:color-mix(in lab,red,red)) {
1088  .from-primary\/\[0\.05\] {
1089    --tw-gradient-from: color-mix(in oklab, var(--primary) 5%, transparent);
1090  }
1091}
1092"#,
1093        )
1094        .unwrap();
1095
1096        assert!(
1097            out.class_map.get("from-primary/[0.05]").is_some(),
1098            "css={}\nkeys={:?}",
1099            out.css,
1100            out.class_map.keys().collect::<Vec<_>>()
1101        );
1102        assert!(out.css.contains("@supports"), "css={}", out.css);
1103        assert!(
1104            out.css.contains("color-mix") && out.css.contains("--tw-gradient-from"),
1105            "css={}",
1106            out.css
1107        );
1108        assert!(
1109            !out.css.contains(".from-primary"),
1110            "original selector leaked: {}",
1111            out.css
1112        );
1113        let hashed = out.class_map.get("from-primary/[0.05]").unwrap();
1114        assert!(out.css.contains(&format!(".{hashed}")));
1115
1116        let rewritten = crate::classes::rewrite_class_string(
1117            "bg-gradient-to-b from-primary/[0.05] to-transparent",
1118            &out.class_map,
1119        );
1120        assert!(
1121            rewritten.contains(hashed.split_whitespace().next().unwrap()),
1122            "rewritten={rewritten}"
1123        );
1124        assert!(!rewritten.contains("from-primary/[0.05]"));
1125    }
1126}