Skip to main content

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