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