Skip to content

armgit / BUI

Public Imported from GitHub
0

Blender's GPU Accelerated UI, Decoupled from it's original codebase. Supports Rust, Python, JS, React, C & C++. Twice as good as GPUI

82.2 KB
Raw Blame
//! Tailwind CSS v4: class names to CSS, like Tailwind's JIT engine.
//!
//! `compile("md:hover:bg-sky-500/50")` gives the rule for that class:
//! variants (state, pseudo-element, `group-*` / `peer-*`, `has-*`, `data-*`,
//! `aria-*`, `nth-*`, breakpoints, container queries, `dark`, `motion-*`,
//! `supports-*`, arbitrary `[&_p]` ...), utilities with the v4 theme,
//! arbitrary values (`w-[calc(100%-2rem)]`), CSS variable shorthand
//! (`bg-(--brand)`), negatives, opacity modifiers and `!important`.
//!
//! Self-contained (std only) so the `tw!` macro can check classes at
//! compile time with the same code.

mod theme;
use theme::THEME;

/// A compiled class: the CSS (inside `@layer utilities`) and its sort key
/// (Tailwind's order: variants, then property order).
#[derive(Clone, Debug, PartialEq)]
pub struct Compiled {
    pub css: String,
    pub sort: (u32, u32),
}

fn theme(name: &str) -> Option<&'static str> {
    THEME.iter().find(|(k, _)| *k == name).map(|(_, v)| *v)
}

/// The rule for `class`, or None when it isn't a Tailwind class.
pub fn compile(class: &str) -> Option<Compiled> {
    let parts = split_variants(class)?;
    let (variants, utility) = parts.split_at(parts.len() - 1);
    let mut utility = utility[0];
    let mut important = false;
    if let Some(u) = utility.strip_suffix('!') {
        utility = u;
        important = true;
    } else if let Some(u) = utility.strip_prefix('!') {
        utility = u;
        important = true;
    }
    let mut out = utility_decls(utility)?;
    let mut sel = format!(".{}", escape(class));
    let mut wrappers: Vec<String> = Vec::new();
    let mut vweight = 0u32;
    let mut pseudo_el = false;
    // variants apply right to left: the leftmost wraps everything
    for v in variants.iter().rev() {
        let (s, w, weight) = variant(v, &sel)?;
        if let Some(s) = s {
            pseudo_el |= s.contains("::before") || s.contains("::after");
            sel = s;
        }
        if let Some(w) = w {
            wrappers.push(w);
        }
        vweight = vweight.max(weight);
    }
    if pseudo_el && !out.decls.iter().any(|(p, _)| p == "content") {
        out.decls.insert(0, ("content".into(), "''".into()));
    }
    let bang = if important { " !important" } else { "" };
    let body: String = out.decls.iter().map(|(p, v)| format!("{p}: {v}{bang}; ")).collect();
    let mut css = match &out.child {
        Some(child) => format!("{} {{ {body}}}", child.replace('&', &sel)),
        None => format!("{sel} {{ {body}}}"),
    };
    for w in wrappers.iter() {
        css = format!("{w} {{ {css} }}");
    }
    let mut full = format!("@layer utilities {{ {css} }}");
    if let Some(k) = out.keyframes {
        full.push('\n');
        full.push_str(k);
    }
    let prank = out.decls.first().map(|(p, _)| prop_rank(p)).unwrap_or(0);
    Some(Compiled { css: full, sort: (vweight, prank) })
}

/// Split `a:b:[&>p]:c` at top-level colons.
fn split_variants(class: &str) -> Option<Vec<&str>> {
    let mut parts = Vec::new();
    let (mut depth, mut start) = (0i32, 0);
    for (k, c) in class.char_indices() {
        match c {
            '[' | '(' => depth += 1,
            ']' | ')' => depth -= 1,
            ':' if depth == 0 => {
                parts.push(&class[start..k]);
                start = k + 1;
            }
            _ => {}
        }
    }
    parts.push(&class[start..]);
    (!parts.iter().any(|p| p.is_empty())).then_some(parts)
}

/// Escape a class name for use in a selector.
pub fn escape(class: &str) -> String {
    let mut out = String::with_capacity(class.len() + 8);
    for (k, c) in class.chars().enumerate() {
        if c.is_ascii_alphanumeric() && !(k == 0 && c.is_ascii_digit()) || c == '-' || c == '_' {
            out.push(c);
        } else {
            out.push('\\');
            out.push(c);
        }
    }
    out
}

/// `[a_b]` contents: underscores are spaces (`\_` stays an underscore).
fn arbitrary(s: &str) -> Option<String> {
    let inner = s.strip_prefix('[')?.strip_suffix(']')?;
    let mut out = String::with_capacity(inner.len());
    let mut it = inner.chars().peekable();
    while let Some(c) = it.next() {
        match c {
            '\\' if it.peek() == Some(&'_') => {
                out.push('_');
                it.next();
            }
            '_' => out.push(' '),
            c => out.push(c),
        }
    }
    Some(out)
}

/// `(--x)` -> `var(--x)`.
fn css_var(s: &str) -> Option<String> {
    let inner = s.strip_prefix('(')?.strip_suffix(')')?;
    let inner = inner.split_once(':').map(|(_, v)| v).unwrap_or(inner);
    inner.starts_with("--").then(|| format!("var({inner})"))
}

/// An arbitrary or variable value, with an optional type hint (`[length:..]`).
fn free(s: &str) -> Option<(Option<String>, String)> {
    if let Some(v) = css_var(s) {
        let hint = s.trim_start_matches('(').split_once(':').map(|(h, _)| h.to_string());
        return Some((hint, v));
    }
    let a = arbitrary(s)?;
    for hint in ["length", "color", "number", "percentage", "url", "image", "position", "size", "family-name",
                 "absolute-size", "relative-size", "line-width", "bg-size", "integer", "angle", "ratio"] {
        if let Some(v) = a.strip_prefix(hint).and_then(|r| r.strip_prefix(':')) {
            return Some((Some(hint.to_string()), v.to_string()));
        }
    }
    Some((None, a))
}

fn is_color_value(v: &str) -> bool {
    let v = v.trim();
    v.starts_with('#') || v.starts_with("rgb") || v.starts_with("hsl") || v.starts_with("oklch")
        || v.starts_with("oklab") || v.starts_with("lab(") || v.starts_with("lch(") || v.starts_with("hwb(")
        || v.starts_with("color(") || v.starts_with("color-mix(") || v.starts_with("light-dark(")
        || v == "transparent" || v == "currentColor" || v == "currentcolor"
        || NAMED_COLORS.contains(&v.to_ascii_lowercase().as_str())
}

const NAMED_COLORS: &[&str] = &[
    "black", "white", "red", "green", "blue", "yellow", "orange", "purple", "pink", "gray", "grey", "silver",
    "maroon", "navy", "teal", "olive", "lime", "aqua", "fuchsia", "cyan", "magenta", "brown", "gold", "indigo",
    "violet", "coral", "salmon", "tomato", "crimson", "khaki", "beige", "ivory", "lavender", "plum", "orchid",
    "tan", "chocolate", "sienna", "peru", "wheat", "linen", "azure", "snow", "mintcream", "honeydew",
    "rebeccapurple", "darkred", "darkgreen", "darkblue", "lightgray", "lightgrey", "darkgray", "darkgrey",
];

/// A spacing value: `4` -> 1rem, `px`, fractions, keywords, arbitrary.
fn spacing(v: &str) -> Option<String> {
    if v == "px" {
        return Some("1px".into());
    }
    if let Some((_, a)) = free(v) {
        return Some(a);
    }
    if let Ok(n) = v.parse::<f32>() {
        if n >= 0.0 && (n * 4.0).fract() == 0.0 {
            let base = theme("spacing")?;
            return Some(if n == 0.0 { "0".into() } else { format!("calc({base} * {})", trim_num(n)) });
        }
    }
    None
}

fn fraction(v: &str) -> Option<String> {
    let (a, b) = v.split_once('/')?;
    let (a, b) = (a.parse::<f32>().ok()?, b.parse::<f32>().ok()?);
    (b != 0.0).then(|| format!("{}%", trim_num(a / b * 100.0)))
}

fn trim_num(n: f32) -> String {
    let s = format!("{n:.6}");
    s.trim_end_matches('0').trim_end_matches('.').to_string()
}

/// Theme colors (`sky-500`), keywords and arbitrary colors, with an
/// optional opacity modifier (`/50`, `/[0.3]`).
fn color(v: &str) -> Option<String> {
    let (base, alpha) = split_modifier(v);
    let c = match base {
        "transparent" => "transparent".to_string(),
        "current" => "currentColor".to_string(),
        "inherit" => "inherit".to_string(),
        "black" | "white" => theme(&format!("color-{base}"))?.to_string(),
        _ => match free(base) {
            Some((hint, a)) if hint.as_deref().is_none_or(|h| h == "color") => {
                if hint.is_none() && !is_color_value(&a) && !a.starts_with("var(") {
                    return None;
                }
                a
            }
            Some(_) => return None,
            None => theme(&format!("color-{base}"))?.to_string(),
        },
    };
    Some(match alpha.and_then(opacity) {
        Some(p) => format!("color-mix(in oklab, {c} {p}, transparent)"),
        None => c,
    })
}

/// `50` -> `50%`, `[0.3]` -> `30%`, `(--a)` -> var.
fn opacity(v: &str) -> Option<String> {
    if let Ok(n) = v.parse::<f32>() {
        return Some(format!("{}%", trim_num(n)));
    }
    let (_, a) = free(v)?;
    Some(match a.parse::<f32>() {
        Ok(n) if n <= 1.0 => format!("{}%", trim_num(n * 100.0)),
        _ => a,
    })
}

/// `bg-red-500/50` -> (`red-500`, `50`); not inside brackets.
fn split_modifier(v: &str) -> (&str, Option<&str>) {
    let mut depth = 0;
    for (k, c) in v.char_indices().rev() {
        match c {
            ']' | ')' => depth += 1,
            '[' | '(' => depth -= 1,
            '/' if depth == 0 => return (&v[..k], Some(&v[k + 1..])),
            _ => {}
        }
    }
    (v, None)
}

/// Utility output: declarations, an optional child selector (`& > :not(:last-child)`)
/// and keyframes it needs.
struct Out {
    decls: Vec<(String, String)>,
    child: Option<String>,
    keyframes: Option<&'static str>,
}

fn decls(list: &[(&str, &str)]) -> Option<Out> {
    Some(Out { decls: list.iter().map(|(p, v)| (p.to_string(), v.to_string())).collect(), child: None, keyframes: None })
}

fn one(p: &str, v: String) -> Option<Out> {
    Some(Out { decls: vec![(p.to_string(), v)], child: None, keyframes: None })
}

fn many(props: &[&str], v: String) -> Option<Out> {
    Some(Out { decls: props.iter().map(|p| (p.to_string(), v.clone())).collect(), child: None, keyframes: None })
}

/// Static utilities: exact class name -> declarations.
const STATIC: &[(&str, &[(&str, &str)])] = &[
    // layout
    ("block", &[("display", "block")]), ("inline-block", &[("display", "inline-block")]),
    ("inline", &[("display", "inline")]), ("flex", &[("display", "flex")]),
    ("inline-flex", &[("display", "inline-flex")]), ("grid", &[("display", "grid")]),
    ("inline-grid", &[("display", "inline-grid")]), ("table", &[("display", "table")]),
    ("inline-table", &[("display", "inline-table")]), ("table-row", &[("display", "table-row")]),
    ("table-cell", &[("display", "table-cell")]), ("table-caption", &[("display", "table-caption")]),
    ("table-row-group", &[("display", "table-row-group")]), ("table-header-group", &[("display", "table-header-group")]),
    ("table-footer-group", &[("display", "table-footer-group")]), ("table-column", &[("display", "table-column")]),
    ("table-column-group", &[("display", "table-column-group")]),
    ("contents", &[("display", "contents")]), ("list-item", &[("display", "list-item")]),
    ("hidden", &[("display", "none")]), ("flow-root", &[("display", "flow-root")]),
    ("sr-only", &[("position", "absolute"), ("width", "1px"), ("height", "1px"), ("padding", "0"),
                  ("margin", "-1px"), ("overflow", "hidden"), ("clip-path", "inset(50%)"), ("white-space", "nowrap"),
                  ("border-width", "0")]),
    ("not-sr-only", &[("position", "static"), ("width", "auto"), ("height", "auto"), ("padding", "0"),
                      ("margin", "0"), ("overflow", "visible"), ("clip-path", "none"), ("white-space", "normal")]),
    ("static", &[("position", "static")]), ("fixed", &[("position", "fixed")]),
    ("absolute", &[("position", "absolute")]), ("relative", &[("position", "relative")]),
    ("sticky", &[("position", "sticky")]),
    ("visible", &[("visibility", "visible")]), ("invisible", &[("visibility", "hidden")]),
    ("collapse", &[("visibility", "collapse")]),
    ("isolate", &[("isolation", "isolate")]), ("isolation-auto", &[("isolation", "auto")]),
    ("box-border", &[("box-sizing", "border-box")]), ("box-content", &[("box-sizing", "content-box")]),
    ("float-left", &[("float", "left")]), ("float-right", &[("float", "right")]),
    ("float-start", &[("float", "inline-start")]), ("float-end", &[("float", "inline-end")]),
    ("float-none", &[("float", "none")]),
    ("clear-left", &[("clear", "left")]), ("clear-right", &[("clear", "right")]),
    ("clear-both", &[("clear", "both")]), ("clear-none", &[("clear", "none")]),
    ("clear-start", &[("clear", "inline-start")]), ("clear-end", &[("clear", "inline-end")]),
    ("container", &[("width", "100%")]),
    ("truncate", &[("overflow", "hidden"), ("text-overflow", "ellipsis"), ("white-space", "nowrap")]),
    // flex & grid
    ("flex-row", &[("flex-direction", "row")]), ("flex-row-reverse", &[("flex-direction", "row-reverse")]),
    ("flex-col", &[("flex-direction", "column")]), ("flex-col-reverse", &[("flex-direction", "column-reverse")]),
    ("flex-wrap", &[("flex-wrap", "wrap")]), ("flex-wrap-reverse", &[("flex-wrap", "wrap-reverse")]),
    ("flex-nowrap", &[("flex-wrap", "nowrap")]),
    ("flex-auto", &[("flex", "auto")]), ("flex-initial", &[("flex", "0 auto")]), ("flex-none", &[("flex", "none")]),
    ("grow", &[("flex-grow", "1")]), ("shrink", &[("flex-shrink", "1")]),
    ("grid-flow-row", &[("grid-auto-flow", "row")]), ("grid-flow-col", &[("grid-auto-flow", "column")]),
    ("grid-flow-dense", &[("grid-auto-flow", "dense")]), ("grid-flow-row-dense", &[("grid-auto-flow", "row dense")]),
    ("grid-flow-col-dense", &[("grid-auto-flow", "column dense")]),
    ("col-auto", &[("grid-column", "auto")]), ("row-auto", &[("grid-row", "auto")]),
    ("col-span-full", &[("grid-column", "1 / -1")]), ("row-span-full", &[("grid-row", "1 / -1")]),
    ("auto-cols-auto", &[("grid-auto-columns", "auto")]), ("auto-cols-min", &[("grid-auto-columns", "min-content")]),
    ("auto-cols-max", &[("grid-auto-columns", "max-content")]), ("auto-cols-fr", &[("grid-auto-columns", "minmax(0, 1fr)")]),
    ("auto-rows-auto", &[("grid-auto-rows", "auto")]), ("auto-rows-min", &[("grid-auto-rows", "min-content")]),
    ("auto-rows-max", &[("grid-auto-rows", "max-content")]), ("auto-rows-fr", &[("grid-auto-rows", "minmax(0, 1fr)")]),
    ("grid-cols-none", &[("grid-template-columns", "none")]), ("grid-rows-none", &[("grid-template-rows", "none")]),
    ("grid-cols-subgrid", &[("grid-template-columns", "subgrid")]), ("grid-rows-subgrid", &[("grid-template-rows", "subgrid")]),
    // typography
    ("italic", &[("font-style", "italic")]), ("not-italic", &[("font-style", "normal")]),
    ("underline", &[("text-decoration-line", "underline")]), ("overline", &[("text-decoration-line", "overline")]),
    ("line-through", &[("text-decoration-line", "line-through")]), ("no-underline", &[("text-decoration-line", "none")]),
    ("uppercase", &[("text-transform", "uppercase")]), ("lowercase", &[("text-transform", "lowercase")]),
    ("capitalize", &[("text-transform", "capitalize")]), ("normal-case", &[("text-transform", "none")]),
    ("text-ellipsis", &[("text-overflow", "ellipsis")]), ("text-clip", &[("text-overflow", "clip")]),
    ("text-wrap", &[("text-wrap", "wrap")]), ("text-nowrap", &[("text-wrap", "nowrap")]),
    ("text-balance", &[("text-wrap", "balance")]), ("text-pretty", &[("text-wrap", "pretty")]),
    ("antialiased", &[("-webkit-font-smoothing", "antialiased")]), ("subpixel-antialiased", &[("-webkit-font-smoothing", "auto")]),
    ("ordinal", &[("font-variant-numeric", "ordinal")]), ("slashed-zero", &[("font-variant-numeric", "slashed-zero")]),
    ("lining-nums", &[("font-variant-numeric", "lining-nums")]), ("oldstyle-nums", &[("font-variant-numeric", "oldstyle-nums")]),
    ("proportional-nums", &[("font-variant-numeric", "proportional-nums")]), ("tabular-nums", &[("font-variant-numeric", "tabular-nums")]),
    ("diagonal-fractions", &[("font-variant-numeric", "diagonal-fractions")]), ("stacked-fractions", &[("font-variant-numeric", "stacked-fractions")]),
    ("normal-nums", &[("font-variant-numeric", "normal")]),
    ("break-normal", &[("overflow-wrap", "normal"), ("word-break", "normal")]), ("break-all", &[("word-break", "break-all")]),
    ("break-keep", &[("word-break", "keep-all")]), ("break-words", &[("overflow-wrap", "break-word")]),
    ("wrap-break-word", &[("overflow-wrap", "break-word")]), ("wrap-anywhere", &[("overflow-wrap", "anywhere")]), ("wrap-normal", &[("overflow-wrap", "normal")]),
    ("hyphens-none", &[("hyphens", "none")]), ("hyphens-manual", &[("hyphens", "manual")]), ("hyphens-auto", &[("hyphens", "auto")]),
    ("list-inside", &[("list-style-position", "inside")]), ("list-outside", &[("list-style-position", "outside")]),
    ("list-none", &[("list-style-type", "none")]), ("list-disc", &[("list-style-type", "disc")]),
    ("list-decimal", &[("list-style-type", "decimal")]),
    ("whitespace-normal", &[("white-space", "normal")]), ("whitespace-nowrap", &[("white-space", "nowrap")]),
    ("whitespace-pre", &[("white-space", "pre")]), ("whitespace-pre-line", &[("white-space", "pre-line")]),
    ("whitespace-pre-wrap", &[("white-space", "pre-wrap")]), ("whitespace-break-spaces", &[("white-space", "break-spaces")]),
    ("decoration-solid", &[("text-decoration-style", "solid")]), ("decoration-double", &[("text-decoration-style", "double")]),
    ("decoration-dotted", &[("text-decoration-style", "dotted")]), ("decoration-dashed", &[("text-decoration-style", "dashed")]),
    ("decoration-wavy", &[("text-decoration-style", "wavy")]),
    ("decoration-from-font", &[("text-decoration-thickness", "from-font")]), ("decoration-auto", &[("text-decoration-thickness", "auto")]),
    ("align-baseline", &[("vertical-align", "baseline")]), ("align-top", &[("vertical-align", "top")]),
    ("align-middle", &[("vertical-align", "middle")]), ("align-bottom", &[("vertical-align", "bottom")]),
    ("align-text-top", &[("vertical-align", "text-top")]), ("align-text-bottom", &[("vertical-align", "text-bottom")]),
    ("align-sub", &[("vertical-align", "sub")]), ("align-super", &[("vertical-align", "super")]),
    // backgrounds
    ("bg-fixed", &[("background-attachment", "fixed")]), ("bg-local", &[("background-attachment", "local")]),
    ("bg-scroll", &[("background-attachment", "scroll")]),
    ("bg-clip-border", &[("background-clip", "border-box")]), ("bg-clip-padding", &[("background-clip", "padding-box")]),
    ("bg-clip-content", &[("background-clip", "content-box")]), ("bg-clip-text", &[("background-clip", "text")]),
    ("bg-origin-border", &[("background-origin", "border-box")]), ("bg-origin-padding", &[("background-origin", "padding-box")]),
    ("bg-origin-content", &[("background-origin", "content-box")]),
    ("bg-repeat", &[("background-repeat", "repeat")]), ("bg-no-repeat", &[("background-repeat", "no-repeat")]),
    ("bg-repeat-x", &[("background-repeat", "repeat-x")]), ("bg-repeat-y", &[("background-repeat", "repeat-y")]),
    ("bg-repeat-round", &[("background-repeat", "round")]), ("bg-repeat-space", &[("background-repeat", "space")]),
    ("bg-auto", &[("background-size", "auto")]), ("bg-cover", &[("background-size", "cover")]),
    ("bg-contain", &[("background-size", "contain")]), ("bg-none", &[("background-image", "none")]),
    // borders
    ("border-solid", &[("border-style", "solid")]), ("border-dashed", &[("border-style", "dashed")]),
    ("border-dotted", &[("border-style", "dotted")]), ("border-double", &[("border-style", "double")]),
    ("border-hidden", &[("border-style", "hidden")]), ("border-none", &[("border-style", "none")]),
    ("outline-hidden", &[("outline", "2px solid transparent"), ("outline-offset", "2px")]),
    ("outline-none", &[("outline-style", "none")]), ("outline-solid", &[("outline-style", "solid")]),
    ("outline-dashed", &[("outline-style", "dashed")]), ("outline-dotted", &[("outline-style", "dotted")]),
    ("outline-double", &[("outline-style", "double")]),
    ("border-collapse", &[("border-collapse", "collapse")]), ("border-separate", &[("border-collapse", "separate")]),
    ("table-auto", &[("table-layout", "auto")]), ("table-fixed", &[("table-layout", "fixed")]),
    ("caption-top", &[("caption-side", "top")]), ("caption-bottom", &[("caption-side", "bottom")]),
    // effects & interactivity
    ("pointer-events-none", &[("pointer-events", "none")]), ("pointer-events-auto", &[("pointer-events", "auto")]),
    ("resize-none", &[("resize", "none")]), ("resize", &[("resize", "both")]), ("resize-x", &[("resize", "horizontal")]),
    ("resize-y", &[("resize", "vertical")]),
    ("select-none", &[("user-select", "none")]), ("select-text", &[("user-select", "text")]),
    ("select-all", &[("user-select", "all")]), ("select-auto", &[("user-select", "auto")]),
    ("appearance-none", &[("appearance", "none")]), ("appearance-auto", &[("appearance", "auto")]),
    ("scroll-auto", &[("scroll-behavior", "auto")]), ("scroll-smooth", &[("scroll-behavior", "smooth")]),
    ("snap-start", &[("scroll-snap-align", "start")]), ("snap-end", &[("scroll-snap-align", "end")]),
    ("snap-center", &[("scroll-snap-align", "center")]), ("snap-align-none", &[("scroll-snap-align", "none")]),
    ("snap-normal", &[("scroll-snap-stop", "normal")]), ("snap-always", &[("scroll-snap-stop", "always")]),
    ("snap-none", &[("scroll-snap-type", "none")]), ("snap-x", &[("scroll-snap-type", "x mandatory")]),
    ("snap-y", &[("scroll-snap-type", "y mandatory")]), ("snap-both", &[("scroll-snap-type", "both mandatory")]),
    ("transform-none", &[("transform", "none")]), ("transform-gpu", &[("will-change", "transform")]),
    ("transform-cpu", &[("will-change", "auto")]),
    ("transform-3d", &[("transform-style", "preserve-3d")]), ("transform-flat", &[("transform-style", "flat")]),
    ("backface-visible", &[("backface-visibility", "visible")]), ("backface-hidden", &[("backface-visibility", "hidden")]),
    ("transition", &[("transition-property", "color, background-color, border-color, outline-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, translate, scale, rotate, filter, backdrop-filter"),
                     ("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)"), ("transition-duration", "150ms")]),
    ("transition-all", &[("transition-property", "all"), ("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)"),
                         ("transition-duration", "150ms")]),
    ("transition-colors", &[("transition-property", "color, background-color, border-color, outline-color, text-decoration-color, fill, stroke"),
                            ("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)"), ("transition-duration", "150ms")]),
    ("transition-opacity", &[("transition-property", "opacity"), ("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)"),
                             ("transition-duration", "150ms")]),
    ("transition-shadow", &[("transition-property", "box-shadow"), ("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)"),
                            ("transition-duration", "150ms")]),
    ("transition-transform", &[("transition-property", "transform, translate, scale, rotate"),
                               ("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)"), ("transition-duration", "150ms")]),
    ("transition-none", &[("transition-property", "none")]),
    ("ease-linear", &[("transition-timing-function", "linear")]),
    ("ease-in", &[("transition-timing-function", "cubic-bezier(0.4, 0, 1, 1)")]),
    ("ease-out", &[("transition-timing-function", "cubic-bezier(0, 0, 0.2, 1)")]),
    ("ease-in-out", &[("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)")]),
    ("ease-initial", &[("transition-timing-function", "initial")]),
    ("animate-none", &[("animation", "none")]),
    ("filter-none", &[("filter", "none")]), ("backdrop-filter-none", &[("backdrop-filter", "none")]),
    ("grayscale", &[("filter", "grayscale(100%)")]), ("invert", &[("filter", "invert(100%)")]),
    ("sepia", &[("filter", "sepia(100%)")]),
    ("backdrop-grayscale", &[("backdrop-filter", "grayscale(100%)")]), ("backdrop-invert", &[("backdrop-filter", "invert(100%)")]),
    ("backdrop-sepia", &[("backdrop-filter", "sepia(100%)")]),
    ("field-sizing-content", &[("field-sizing", "content")]), ("field-sizing-fixed", &[("field-sizing", "fixed")]),
    ("scheme-normal", &[("color-scheme", "normal")]), ("scheme-dark", &[("color-scheme", "dark")]),
    ("scheme-light", &[("color-scheme", "light")]), ("scheme-light-dark", &[("color-scheme", "light dark")]),
    ("scheme-only-dark", &[("color-scheme", "only dark")]), ("scheme-only-light", &[("color-scheme", "only light")]),
    ("forced-color-adjust-auto", &[("forced-color-adjust", "auto")]), ("forced-color-adjust-none", &[("forced-color-adjust", "none")]),
    ("object-contain", &[("object-fit", "contain")]), ("object-cover", &[("object-fit", "cover")]),
    ("object-fill", &[("object-fit", "fill")]), ("object-none", &[("object-fit", "none")]),
    ("object-scale-down", &[("object-fit", "scale-down")]),
    ("overflow-auto", &[("overflow", "auto")]), ("overflow-hidden", &[("overflow", "hidden")]),
    ("overflow-clip", &[("overflow", "clip")]), ("overflow-visible", &[("overflow", "visible")]),
    ("overflow-scroll", &[("overflow", "scroll")]),
    ("overflow-x-auto", &[("overflow-x", "auto")]), ("overflow-y-auto", &[("overflow-y", "auto")]),
    ("overflow-x-hidden", &[("overflow-x", "hidden")]), ("overflow-y-hidden", &[("overflow-y", "hidden")]),
    ("overflow-x-clip", &[("overflow-x", "clip")]), ("overflow-y-clip", &[("overflow-y", "clip")]),
    ("overflow-x-visible", &[("overflow-x", "visible")]), ("overflow-y-visible", &[("overflow-y", "visible")]),
    ("overflow-x-scroll", &[("overflow-x", "scroll")]), ("overflow-y-scroll", &[("overflow-y", "scroll")]),
    ("overscroll-auto", &[("overscroll-behavior", "auto")]), ("overscroll-contain", &[("overscroll-behavior", "contain")]),
    ("overscroll-none", &[("overscroll-behavior", "none")]),
    ("bg-blend-normal", &[("background-blend-mode", "normal")]),
    ("mix-blend-normal", &[("mix-blend-mode", "normal")]), ("mix-blend-plus-darker", &[("mix-blend-mode", "plus-darker")]),
    ("mix-blend-plus-lighter", &[("mix-blend-mode", "plus-lighter")]),
    ("content-none", &[("content", "none")]),
    ("break-before-auto", &[("break-before", "auto")]), ("break-after-auto", &[("break-after", "auto")]),
    ("break-inside-auto", &[("break-inside", "auto")]), ("break-inside-avoid", &[("break-inside", "avoid")]),
    ("box-decoration-clone", &[("box-decoration-break", "clone")]), ("box-decoration-slice", &[("box-decoration-break", "slice")]),
    ("touch-auto", &[("touch-action", "auto")]), ("touch-none", &[("touch-action", "none")]),
    ("touch-manipulation", &[("touch-action", "manipulation")]),
    ("will-change-auto", &[("will-change", "auto")]), ("will-change-scroll", &[("will-change", "scroll-position")]),
    ("will-change-contents", &[("will-change", "contents")]), ("will-change-transform", &[("will-change", "transform")]),
    ("rounded-none", &[("border-radius", "0")]), ("rounded-full", &[("border-radius", "calc(infinity * 1px)")]),
    ("shadow-none", &[("box-shadow", "0 0 #0000")]), ("inset-shadow-none", &[("box-shadow", "0 0 #0000")]),
    ("text-shadow-none", &[("text-shadow", "none")]), ("drop-shadow-none", &[("filter", "drop-shadow(0 0 #0000)")]),
];

const BLEND: &[&str] = &["multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn",
                         "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"];

const CURSORS: &[&str] = &["auto", "default", "pointer", "wait", "text", "move", "help", "not-allowed", "none",
    "context-menu", "progress", "cell", "crosshair", "vertical-text", "alias", "copy", "no-drop", "grab", "grabbing",
    "all-scroll", "col-resize", "row-resize", "n-resize", "e-resize", "s-resize", "w-resize", "ne-resize", "nw-resize",
    "se-resize", "sw-resize", "ew-resize", "ns-resize", "nesw-resize", "nwse-resize", "zoom-in", "zoom-out"];

/// Sizes for width / height: spacing, fractions, keywords, containers.
fn size(v: &str, axis: char) -> Option<String> {
    Some(match v {
        "auto" => "auto".into(),
        "full" => "100%".into(),
        "screen" => if axis == 'w' { "100vw".into() } else { "100vh".into() },
        "dvw" | "svw" | "lvw" | "dvh" | "svh" | "lvh" => format!("100{v}"),
        "min" => "min-content".into(),
        "max" => "max-content".into(),
        "fit" => "fit-content".into(),
        "lh" => "1lh".into(),
        "none" => "none".into(),
        "prose" => "65ch".into(),
        _ if axis == 'w' && theme(&format!("container-{v}")).is_some() => theme(&format!("container-{v}"))?.into(),
        _ if v.starts_with("screen-") => theme(&format!("breakpoint-{}", &v[7..]))?.into(),
        _ => fraction(v).or_else(|| spacing(v))?,
    })
}

fn sides(prefix: &str) -> Option<&'static [&'static str]> {
    Some(match prefix {
        "" => &[""],
        "x" => &["-inline"],
        "y" => &["-block"],
        "s" => &["-inline-start"],
        "e" => &["-inline-end"],
        "t" => &["-top"],
        "r" => &["-right"],
        "b" => &["-bottom"],
        "l" => &["-left"],
        "bs" => &["-block-start"],
        "be" => &["-block-end"],
        _ => return None,
    })
}

/// The declarations for one utility (no variants).
fn utility_decls(u: &str) -> Option<Out> {
    // arbitrary property: [mask-type:luminance]
    if u.starts_with('[') && u.ends_with(']') {
        let a = arbitrary(u)?;
        let (p, v) = a.split_once(':')?;
        return one(p.trim(), v.trim().to_string());
    }
    if let Some((_, d)) = STATIC.iter().find(|(n, _)| *n == u) {
        return decls(d);
    }
    let (neg, u) = match u.strip_prefix('-') {
        Some(r) => (true, r),
        None => (false, u),
    };
    let negate = |v: String| if neg { format!("calc({v} * -1)") } else { v };
    // longest matching root first
    let (root, val) = split_root(u)?;
    let v = val;
    let out = match root {
        // ---- spacing
        "p" | "px" | "py" | "ps" | "pe" | "pt" | "pr" | "pb" | "pl" | "pbs" | "pbe" if !neg => {
            let s = sides(&root[1..])?;
            let val = spacing(v)?;
            let props: Vec<String> = s.iter().map(|x| format!("padding{x}")).collect();
            Out { decls: props.into_iter().map(|p| (p, val.clone())).collect(), child: None, keyframes: None }
        }
        "m" | "mx" | "my" | "ms" | "me" | "mt" | "mr" | "mb" | "ml" | "mbs" | "mbe" => {
            let s = sides(&root[1..])?;
            let val = if v == "auto" { "auto".into() } else { negate(spacing(v)?) };
            Out { decls: s.iter().map(|x| (format!("margin{x}"), val.clone())).collect(), child: None, keyframes: None }
        }
        "space-x" | "space-y" => {
            let val = negate(spacing(v)?);
            let p = if root == "space-x" { "margin-inline-end" } else { "margin-block-end" };
            Out { decls: vec![(p.into(), val)], child: Some("& > :not(:last-child)".into()), keyframes: None }
        }
        "gap" | "gap-x" | "gap-y" if !neg => {
            let p = match root { "gap" => "gap", "gap-x" => "column-gap", _ => "row-gap" };
            one(p, spacing(v)?)?
        }
        // ---- sizing
        "w" | "min-w" | "max-w" if !neg => {
            let p = match root { "w" => "width", "min-w" => "min-width", _ => "max-width" };
            one(p, size(v, 'w')?)?
        }
        "h" | "min-h" | "max-h" if !neg => {
            let p = match root { "h" => "height", "min-h" => "min-height", _ => "max-height" };
            one(p, size(v, 'h')?)?
        }
        "size" if !neg => many(&["width", "height"], size(v, 'w')?)?,
        "inline" | "min-inline" | "max-inline" if !neg => {
            let p = match root { "inline" => "inline-size", "min-inline" => "min-inline-size", _ => "max-inline-size" };
            one(p, size(v, 'w')?)?
        }
        "block" | "min-block" | "max-block" if !neg => {
            let p = match root { "block" => "block-size", "min-block" => "min-block-size", _ => "max-block-size" };
            one(p, size(v, 'h')?)?
        }
        // ---- position
        "inset" | "inset-x" | "inset-y" | "start" | "end" | "top" | "right" | "bottom" | "left" => {
            let val = match v {
                "auto" => "auto".into(),
                "full" => negate("100%".into()),
                _ => negate(fraction(v).or_else(|| spacing(v))?),
            };
            let props: &[&str] = match root {
                "inset" => &["inset"],
                "inset-x" => &["inset-inline"],
                "inset-y" => &["inset-block"],
                "start" => &["inset-inline-start"],
                "end" => &["inset-inline-end"],
                r => std::slice::from_ref(match r { "top" => &"top", "right" => &"right", "bottom" => &"bottom", _ => &"left" }),
            };
            many(props, val)?
        }
        "z" => one("z-index", if v == "auto" { "auto".into() } else { negate(int_or_free(v)?) })?,
        "order" => one("order", match v {
            "first" => "-9999".into(),
            "last" => "9999".into(),
            "none" => "0".into(),
            _ => negate(int_or_free(v)?),
        })?,
        // ---- flex & grid
        "basis" if !neg => one("flex-basis", match v {
            "auto" => "auto".into(),
            "full" => "100%".into(),
            _ => match theme(&format!("container-{v}")) {
                Some(c) => c.into(),
                None => fraction(v).or_else(|| spacing(v))?,
            },
        })?,
        "flex" if !neg => one("flex", match v {
            _ if v.contains('/') && !v.starts_with('[') => format!("{} 1 0%", fraction(v)?),
            _ => num_or_free(v)?,
        })?,
        "grow" | "shrink" if !neg => one(if root == "grow" { "flex-grow" } else { "flex-shrink" }, num_or_free(v)?)?,
        "grid-cols" | "grid-rows" if !neg => {
            let p = if root == "grid-cols" { "grid-template-columns" } else { "grid-template-rows" };
            one(p, match v.parse::<u32>() {
                Ok(n) => format!("repeat({n}, minmax(0, 1fr))"),
                Err(_) => free(v)?.1,
            })?
        }
        "col-span" | "row-span" if !neg => {
            let p = if root == "col-span" { "grid-column" } else { "grid-row" };
            one(p, format!("span {} / span {}", int_or_free(v)?, int_or_free(v)?))?
        }
        "col-start" | "col-end" | "row-start" | "row-end" => {
            let p = match root {
                "col-start" => "grid-column-start",
                "col-end" => "grid-column-end",
                "row-start" => "grid-row-start",
                _ => "grid-row-end",
            };
            one(p, if v == "auto" { "auto".into() } else { negate(int_or_free(v)?) })?
        }
        "col" | "row" if !neg => one(if root == "col" { "grid-column" } else { "grid-row" }, int_or_free(v)?)?,
        "auto-cols" | "auto-rows" if !neg => one(if root == "auto-cols" { "grid-auto-columns" } else { "grid-auto-rows" }, free(v)?.1)?,
        "justify" | "justify-items" | "justify-self" | "content" | "items" | "self" | "place-content" | "place-items"
        | "place-self" if !neg && align_kw(root, v).is_some() => {
            let p = match root {
                "justify" => "justify-content",
                "justify-items" => "justify-items",
                "justify-self" => "justify-self",
                "content" => "align-content",
                "items" => "align-items",
                "self" => "align-self",
                r => r,
            };
            one(p, align_kw(root, v)?)?
        }
        // ---- typography
        "font" if !neg => match v {
            "sans" | "serif" | "mono" => one("font-family", theme(&format!("font-{v}"))?.into())?,
            _ => match theme(&format!("font-weight-{v}")) {
                Some(w) => one("font-weight", w.into())?,
                None => {
                    let (hint, a) = free(v)?;
                    if hint.as_deref() == Some("family-name") || a.parse::<f32>().is_err() && !a.starts_with("var(") {
                        one("font-family", a)?
                    } else {
                        one("font-weight", a)?
                    }
                }
            },
        },
        "text" if !neg => {
            let (base, lh) = split_modifier(v);
            if let Some(sz) = theme(&format!("text-{base}")) {
                let line = match lh {
                    Some(l) => leading(l)?,
                    None => theme(&format!("text-{base}--line-height")).unwrap_or("1.5").to_string(),
                };
                decls(&[("font-size", sz), ("line-height", &line)])?
            } else if matches!(v, "left" | "center" | "right" | "justify" | "start" | "end") {
                one("text-align", v.into())?
            } else if let Some(c) = color(v) {
                one("color", c)?
            } else {
                let (hint, a) = free(base)?;
                match hint.as_deref() {
                    Some("length") | Some("absolute-size") | Some("relative-size") => one("font-size", a)?,
                    _ if a.ends_with("px") || a.ends_with("rem") || a.ends_with("em") || a.contains("calc") => one("font-size", a)?,
                    _ => one("color", a)?,
                }
            }
        }
        "tracking" => one("letter-spacing", match theme(&format!("tracking-{v}")) {
            Some(t) => negate(t.into()),
            None => negate(free(v)?.1),
        })?,
        "leading" if !neg => one("line-height", leading(v)?)?,
        "line-clamp" if !neg => match v {
            "none" => decls(&[("overflow", "visible"), ("display", "block"), ("-webkit-box-orient", "horizontal"),
                              ("-webkit-line-clamp", "unset")])?,
            _ => {
                let n = int_or_free(v)?;
                decls(&[("overflow", "hidden"), ("display", "-webkit-box"), ("-webkit-box-orient", "vertical"),
                        ("-webkit-line-clamp", &n), ("line-clamp", &n)])?
            }
        },
        "indent" => one("text-indent", negate(spacing(v)?))?,
        "decoration" if !neg => match color(v) {
            Some(c) => one("text-decoration-color", c)?,
            None => one("text-decoration-thickness", px_or_free(v)?)?,
        },
        "underline-offset" => one("text-underline-offset", if v == "auto" { "auto".into() } else { negate(px_or_free(v)?) })?,
        "list" if !neg => one("list-style-type", free(v)?.1)?,
        "list-image" if !neg => one("list-style-image", if v == "none" { "none".into() } else { free(v)?.1 })?,
        "content" if !neg => one("content", free(v)?.1)?,
        "align" if !neg => one("vertical-align", free(v)?.1)?,
        // ---- backgrounds
        "bg" if !neg => {
            if let Some(c) = color(v) {
                one("background-color", c)?
            } else if let Some(dir) = v.strip_prefix("linear-to-").or_else(|| v.strip_prefix("gradient-to-")) {
                let to = dir_words(dir)?;
                one("background-image", format!("linear-gradient(to {to}, var(--tw-gradient-stops))"))?
            } else if let Some(rest) = v.strip_prefix("linear-") {
                let a = if let Ok(n) = rest.parse::<f32>() { format!("{n}deg") } else { free(rest)?.1 };
                one("background-image", format!("linear-gradient({a}, var(--tw-gradient-stops))"))?
            } else if v == "radial" {
                one("background-image", "radial-gradient(var(--tw-gradient-stops))".into())?
            } else if let Some(rest) = v.strip_prefix("radial-") {
                one("background-image", format!("radial-gradient({}, var(--tw-gradient-stops))", free(rest)?.1))?
            } else if v == "conic" {
                one("background-image", "conic-gradient(var(--tw-gradient-stops))".into())?
            } else if let Some(rest) = v.strip_prefix("conic-") {
                let a = if let Ok(n) = rest.parse::<f32>() { format!("from {n}deg") } else { free(rest)?.1 };
                one("background-image", format!("conic-gradient({a}, var(--tw-gradient-stops))"))?
            } else if let Some(p) = position_kw(v) {
                one("background-position", p)?
            } else {
                let (hint, a) = free(v)?;
                match hint.as_deref() {
                    Some("length") | Some("size") | Some("bg-size") => one("background-size", a)?,
                    Some("position") => one("background-position", a)?,
                    _ if a.starts_with("url(") || a.contains("gradient(") || hint.as_deref() == Some("image") || hint.as_deref() == Some("url") => {
                        one("background-image", a)?
                    }
                    _ => one("background-color", a)?,
                }
            }
        }
        "from" | "via" | "to" if !neg => {
            if let Some(c) = color(v) {
                let stops = match root {
                    "from" => format!("{c}, var(--tw-gradient-via, {c}), var(--tw-gradient-to, transparent)"),
                    "via" => format!("var(--tw-gradient-from, transparent), {c}, var(--tw-gradient-to, transparent)"),
                    _ => format!("var(--tw-gradient-from, transparent), var(--tw-gradient-via, {c}), {c}"),
                };
                Out { decls: vec![(format!("--tw-gradient-{root}"), c), ("--tw-gradient-stops".into(), stops)],
                      child: None, keyframes: None }
            } else {
                one(&format!("--tw-gradient-{root}-position"), pct_or_free(v)?)?
            }
        }
        "bg-blend" if !neg && BLEND.contains(&v) => one("background-blend-mode", v.into())?,
        "mix-blend" if !neg && BLEND.contains(&v) => one("mix-blend-mode", v.into())?,
        // ---- borders
        "border" | "border-x" | "border-y" | "border-s" | "border-e" | "border-t" | "border-r" | "border-b"
        | "border-l" | "border-bs" | "border-be" if !neg => {
            let s = sides(root.strip_prefix("border-").unwrap_or(""))?;
            match border_width(v) {
                Some(w) => Out { decls: s.iter().map(|x| (format!("border{x}-width"), w.clone())).collect(),
                                 child: None, keyframes: None },
                None => {
                    let c = color(v)?;
                    Out { decls: s.iter().map(|x| (format!("border{x}-color"), c.clone())).collect(), child: None, keyframes: None }
                }
            }
        }
        "rounded" | "rounded-s" | "rounded-e" | "rounded-t" | "rounded-r" | "rounded-b" | "rounded-l" | "rounded-ss"
        | "rounded-se" | "rounded-ee" | "rounded-es" | "rounded-tl" | "rounded-tr" | "rounded-br" | "rounded-bl" if !neg => {
            let r = radius(v)?;
            let props: &[&str] = match root {
                "rounded" => &["border-radius"],
                "rounded-s" => &["border-start-start-radius", "border-end-start-radius"],
                "rounded-e" => &["border-start-end-radius", "border-end-end-radius"],
                "rounded-t" => &["border-top-left-radius", "border-top-right-radius"],
                "rounded-r" => &["border-top-right-radius", "border-bottom-right-radius"],
                "rounded-b" => &["border-bottom-right-radius", "border-bottom-left-radius"],
                "rounded-l" => &["border-top-left-radius", "border-bottom-left-radius"],
                "rounded-ss" => &["border-start-start-radius"],
                "rounded-se" => &["border-start-end-radius"],
                "rounded-ee" => &["border-end-end-radius"],
                "rounded-es" => &["border-end-start-radius"],
                "rounded-tl" => &["border-top-left-radius"],
                "rounded-tr" => &["border-top-right-radius"],
                "rounded-br" => &["border-bottom-right-radius"],
                _ => &["border-bottom-left-radius"],
            };
            many(props, r)?
        }
        "divide-x" | "divide-y" if !neg => {
            let w = border_width(v)?;
            let p = if root == "divide-x" { "border-inline-start-width" } else { "border-top-width" };
            Out { decls: vec![(p.into(), w)], child: Some("& > :not(:last-child) ~ *".into()), keyframes: None }
        }
        "divide" if !neg => Out { decls: vec![("border-color".into(), color(v)?)],
                                  child: Some("& > :not(:last-child)".into()), keyframes: None },
        "outline" if !neg => match border_width(v) {
            Some(w) => decls(&[("outline-style", "solid"), ("outline-width", &w)])?,
            None => one("outline-color", color(v)?)?,
        },
        "outline-offset" => one("outline-offset", negate(px_or_free(v)?))?,
        "ring" | "inset-ring" if !neg => {
            let inset = if root == "inset-ring" { "inset " } else { "" };
            match border_width(v) {
                Some(w) => one("box-shadow", format!("{inset}0 0 0 {w} var(--tw-ring-color, currentColor)"))?,
                None => one("--tw-ring-color", color(v)?)?,
            }
        }
        "ring-offset" if !neg => match border_width(v) {
            Some(w) => one("--tw-ring-offset-width", w)?,
            None => one("--tw-ring-offset-color", color(v)?)?,
        },
        // ---- effects
        "shadow" | "inset-shadow" | "drop-shadow" | "text-shadow" if !neg => {
            let (base, alpha) = split_modifier(v);
            let key = format!("{root}-{base}");
            let theme_shadow = theme(&key).or_else(|| (base == "DEFAULT").then(|| match root {
                "shadow" => "0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)",
                "drop-shadow" => "0 1px 2px rgb(0 0 0 / 0.1), 0 1px 1px rgb(0 0 0 / 0.06)",
                "inset-shadow" => "inset 0 2px 4px rgb(0 0 0 / 0.05)",
                _ => "0px 1px 1px rgb(0 0 0 / 0.2)",
            }));
            if let Some(s) = theme_shadow {
                // `shadow-lg/50`: the shadow color's alpha becomes 50%
                let s = match alpha.and_then(opacity) {
                    Some(a) => with_shadow_alpha(s, &a),
                    None => s.to_string(),
                };
                match root {
                    "drop-shadow" => one("filter", s.split(", ").map(|d| format!("drop-shadow({d})")).collect::<Vec<_>>().join(" "))?,
                    "text-shadow" => one("text-shadow", s)?,
                    _ => one("box-shadow", s)?,
                }
            } else if let Some(c) = color(v) {
                one(&format!("--tw-{root}-color"), c)?
            } else {
                let a = free(v)?.1;
                match root {
                    "drop-shadow" => one("filter", format!("drop-shadow({a})"))?,
                    "text-shadow" => one("text-shadow", a)?,
                    "inset-shadow" => one("box-shadow", format!("inset {a}"))?,
                    _ => one("box-shadow", a)?,
                }
            }
        }
        "opacity" if !neg => one("opacity", opacity(v)?)?,
        "blur" | "backdrop-blur" if !neg => {
            let b = match v {
                "none" => "0".to_string(),
                "DEFAULT" => "8px".to_string(),
                _ => theme(&format!("blur-{v}")).map(String::from).or_else(|| free(v).map(|f| f.1))?,
            };
            one(if root == "blur" { "filter" } else { "backdrop-filter" }, format!("blur({b})"))?
        }
        "brightness" | "contrast" | "saturate" | "backdrop-brightness" | "backdrop-contrast" | "backdrop-saturate" if !neg => {
            let f = root.trim_start_matches("backdrop-");
            let p = if root.starts_with("backdrop") { "backdrop-filter" } else { "filter" };
            one(p, format!("{f}({})", pct_num(v)?))?
        }
        "grayscale" | "invert" | "sepia" | "backdrop-grayscale" | "backdrop-invert" | "backdrop-sepia" | "backdrop-opacity" if !neg => {
            let f = root.trim_start_matches("backdrop-");
            let p = if root.starts_with("backdrop") { "backdrop-filter" } else { "filter" };
            one(p, format!("{f}({})", pct_num(v)?))?
        }
        "hue-rotate" | "backdrop-hue-rotate" => {
            let p = if root.starts_with("backdrop") { "backdrop-filter" } else { "filter" };
            one(p, format!("hue-rotate({})", negate(deg(v)?)))?
        }
        // ---- transforms
        "scale" | "scale-x" | "scale-y" | "scale-z" => {
            let s = negate(pct_num(v)?);
            match root {
                "scale" => one("scale", s)?,
                "scale-x" => one("scale", format!("{s} 1"))?,
                "scale-y" => one("scale", format!("1 {s}"))?,
                _ => one("scale", format!("1 1 {s}"))?,
            }
        }
        "rotate" | "rotate-x" | "rotate-y" | "rotate-z" => {
            let d = negate(deg(v)?);
            match root {
                "rotate" => one("rotate", d)?,
                "rotate-x" => one("rotate", format!("x {d}"))?,
                "rotate-y" => one("rotate", format!("y {d}"))?,
                _ => one("rotate", format!("z {d}"))?,
            }
        }
        "translate" | "translate-x" | "translate-y" | "translate-z" => {
            let t = negate(match v { "full" => "100%".into(), "px" => "1px".into(), _ => fraction(v).or_else(|| spacing(v))? });
            match root {
                "translate" => one("translate", format!("{t} {t}"))?,
                "translate-x" => one("translate", format!("{t} 0"))?,
                "translate-y" => one("translate", format!("0 {t}"))?,
                _ => one("translate", format!("0 0 {t}"))?,
            }
        }
        "skew" | "skew-x" | "skew-y" => {
            let d = negate(deg(v)?);
            match root {
                "skew" => one("transform", format!("skewX({d}) skewY({d})"))?,
                "skew-x" => one("transform", format!("skewX({d})"))?,
                _ => one("transform", format!("skewY({d})"))?,
            }
        }
        "origin" | "perspective-origin" if !neg => one(if root == "origin" { "transform-origin" } else { "perspective-origin" },
                                                        position_kw(v).or_else(|| free(v).map(|f| f.1))?)?,
        "perspective" if !neg => one("perspective", match v {
            "none" => "none".into(),
            _ => theme(&format!("perspective-{v}")).map(String::from).or_else(|| free(v).map(|f| f.1))?,
        })?,
        "transform" if !neg => one("transform", free(v)?.1)?,
        // ---- transitions & animation
        "transition" if !neg => decls(&[("transition-property", &free(v)?.1),
                                         ("transition-timing-function", "cubic-bezier(0.4, 0, 0.2, 1)"),
                                         ("transition-duration", "150ms")])?,
        "duration" | "delay" if !neg => {
            let ms = match v.parse::<f32>() {
                Ok(n) => format!("{}ms", trim_num(n)),
                Err(_) if v == "initial" => "initial".into(),
                Err(_) => free(v)?.1,
            };
            one(if root == "duration" { "transition-duration" } else { "transition-delay" }, ms)?
        }
        "ease" if !neg => one("transition-timing-function", free(v)?.1)?,
        "animate" if !neg => {
            let (anim, kf): (String, &'static str) = match v {
                "spin" => (theme("animate-spin")?.into(), "@keyframes spin { to { transform: rotate(360deg) } }"),
                "ping" => (theme("animate-ping")?.into(),
                           "@keyframes ping { 75%, 100% { transform: scale(2); opacity: 0 } }"),
                "pulse" => (theme("animate-pulse")?.into(), "@keyframes pulse { 50% { opacity: 0.5 } }"),
                "bounce" => (theme("animate-bounce")?.into(),
                             "@keyframes bounce { 0%, 100% { transform: translateY(-25%); animation-timing-function: cubic-bezier(0.8, 0, 1, 1) } 50% { transform: none; animation-timing-function: cubic-bezier(0, 0, 0.2, 1) } }"),
                _ => (free(v)?.1, ""),
            };
            Out { decls: vec![("animation".into(), anim)], child: None, keyframes: (!kf.is_empty()).then_some(kf) }
        }
        // ---- interactivity, svg, misc
        "cursor" if !neg => one("cursor", if CURSORS.contains(&v) { v.into() } else { free(v)?.1 })?,
        "accent" if !neg => one("accent-color", if v == "auto" { "auto".into() } else { color(v)? })?,
        "caret" if !neg => one("caret-color", color(v)?)?,
        "fill" if !neg => one("fill", if v == "none" { "none".into() } else { color(v)? })?,
        "stroke" if !neg => match color(v) {
            Some(c) => one("stroke", c)?,
            None => one("stroke-width", num_or_free(v)?)?,
        },
        "aspect" if !neg => one("aspect-ratio", match v {
            "auto" => "auto".into(),
            "square" => "1 / 1".into(),
            "video" => theme("aspect-video")?.into(),
            _ if v.contains('/') && !v.starts_with('[') => v.replace('/', " / "),
            _ => free(v)?.1,
        })?,
        "columns" if !neg => one("columns", match v {
            "auto" => "auto".into(),
            _ if v.parse::<u32>().is_ok() => v.into(),
            _ => theme(&format!("container-{v}")).map(String::from).or_else(|| free(v).map(|f| f.1))?,
        })?,
        "object" if !neg => one("object-position", position_kw(v).or_else(|| free(v).map(|f| f.1))?)?,
        "scroll-m" | "scroll-mx" | "scroll-my" | "scroll-ms" | "scroll-me" | "scroll-mt" | "scroll-mr" | "scroll-mb"
        | "scroll-ml" => {
            let s = sides(&root[8..])?;
            let val = negate(spacing(v)?);
            Out { decls: s.iter().map(|x| (format!("scroll-margin{x}"), val.clone())).collect(), child: None, keyframes: None }
        }
        "scroll-p" | "scroll-px" | "scroll-py" | "scroll-ps" | "scroll-pe" | "scroll-pt" | "scroll-pr" | "scroll-pb"
        | "scroll-pl" if !neg => {
            let s = sides(&root[8..])?;
            let val = spacing(v)?;
            Out { decls: s.iter().map(|x| (format!("scroll-padding{x}"), val.clone())).collect(), child: None, keyframes: None }
        }
        "will-change" if !neg => one("will-change", free(v)?.1)?,
        "touch" if !neg && matches!(v, "pan-x" | "pan-left" | "pan-right" | "pan-y" | "pan-up" | "pan-down"
                                  | "pinch-zoom") => one("touch-action", v.into())?,
        "border-spacing" | "border-spacing-x" | "border-spacing-y" if !neg => one("border-spacing", spacing(v)?)?,
        "break-before" | "break-after" | "break-inside" if !neg => one(root, v.into())?,
        "mask" if !neg => one("mask-image", free(v)?.1)?,
        "outline-style" => return None,
        _ => return None,
    };
    Some(out)
}

const ROOTS: &[&str] = &[
    "backdrop-hue-rotate", "backdrop-brightness", "backdrop-contrast", "backdrop-grayscale", "backdrop-saturate",
    "backdrop-opacity", "backdrop-invert", "backdrop-sepia", "backdrop-blur", "perspective-origin",
    "underline-offset", "outline-offset", "border-spacing-x", "border-spacing-y", "border-spacing", "inset-shadow",
    "drop-shadow", "text-shadow", "justify-items", "justify-self", "place-content", "place-items", "place-self",
    "ring-offset", "inset-ring", "will-change", "line-clamp", "list-image", "hue-rotate", "break-before",
    "break-after", "break-inside", "min-inline", "max-inline", "min-block", "max-block", "translate-x",
    "translate-y", "translate-z", "grid-cols", "grid-rows", "col-start", "row-start", "auto-cols", "auto-rows",
    "brightness", "grayscale", "translate", "perspective", "col-span", "row-span", "col-end", "row-end",
    "rounded-ss", "rounded-se", "rounded-ee", "rounded-es", "rounded-tl", "rounded-tr", "rounded-br",
    "rounded-bl", "rounded-s", "rounded-e", "rounded-t", "rounded-r", "rounded-b", "rounded-l", "rounded",
    "border-x", "border-y", "border-s", "border-e", "border-t", "border-r", "border-b", "border-l",
    "border-bs", "border-be", "divide-x", "divide-y", "scroll-mx", "scroll-my", "scroll-ms", "scroll-me",
    "scroll-mt", "scroll-mr", "scroll-mb", "scroll-ml", "scroll-px", "scroll-py", "scroll-ps", "scroll-pe",
    "scroll-pt", "scroll-pr", "scroll-pb", "scroll-pl", "scroll-m", "scroll-p", "rotate-x", "rotate-y",
    "rotate-z", "scale-x", "scale-y", "scale-z", "skew-x", "skew-y", "space-x", "space-y", "bg-blend",
    "mix-blend", "contrast", "saturate", "duration", "tracking", "leading", "opacity", "content", "columns",
    "inset-x", "inset-y", "transform", "transition", "animate", "decoration", "outline", "origin", "invert",
    "sepia", "divide", "border", "shadow", "rotate", "scale", "skew", "basis", "order", "accent", "caret",
    "cursor", "stroke", "aspect", "object", "indent", "gap-x", "gap-y", "min-w", "max-w", "min-h", "max-h",
    "inline", "block", "inset", "start", "items", "justify", "self", "align", "delay", "ease", "blur", "ring",
    "fill", "font", "text", "list", "mask", "touch", "size", "flex", "grow", "shrink", "from", "via", "top",
    "right", "bottom", "left", "end", "col", "row", "gap", "pbs", "pbe", "mbs", "mbe", "bg", "to", "z",
    "px", "py", "ps", "pe", "pt", "pr", "pb", "pl", "mx", "my", "ms", "me", "mt", "mr", "mb", "ml", "p", "m",
    "w", "h",
    ];

/// Split `p-4` into (`p`, `4`) using the longest known root.
fn split_root(u: &str) -> Option<(&str, &str)> {

    for r in ROOTS {
        if let Some(rest) = u.strip_prefix(r) {
            if let Some(v) = rest.strip_prefix('-') {
                if !v.is_empty() {
                    return Some((r, v));
                }
            }
            if rest.is_empty() {
                // bare roots with a default value
                return match *r {
                    "border" | "border-x" | "border-y" | "border-s" | "border-e" | "border-t" | "border-r"
                    | "border-b" | "border-l" | "outline" | "ring" | "inset-ring" | "divide-x" | "divide-y" => Some((r, "1")),
                    "rounded" | "shadow" | "drop-shadow" | "blur" | "backdrop-blur" | "inset-shadow" => Some((r, "DEFAULT")),
                    "grow" | "shrink" => Some((r, "1")),
                    _ => None,
                };
            }
        }
    }
    None
}

/// Every `rgb(0 0 0 / x)` in a theme shadow with alpha `a`.
fn with_shadow_alpha(s: &str, a: &str) -> String {
    let mut out = String::with_capacity(s.len());
    let mut rest = s;
    while let Some(k) = rest.find("rgb(0 0 0 / ") {
        out.push_str(&rest[..k + 12]);
        out.push_str(a);
        let after = &rest[k + 12..];
        let end = after.find(')').unwrap_or(after.len());
        rest = &after[end..];
    }
    out.push_str(rest);
    out
}

fn int_or_free(v: &str) -> Option<String> {
    if v.parse::<i32>().is_ok() {
        return Some(v.into());
    }
    free(v).map(|f| f.1)
}

fn num_or_free(v: &str) -> Option<String> {
    if v.parse::<f32>().is_ok() {
        return Some(v.into());
    }
    free(v).map(|f| f.1)
}

fn px_or_free(v: &str) -> Option<String> {
    if let Ok(n) = v.parse::<f32>() {
        return Some(format!("{}px", trim_num(n)));
    }
    free(v).map(|f| f.1)
}

fn pct_or_free(v: &str) -> Option<String> {
    if let Some(p) = v.strip_suffix('%') {
        return p.parse::<f32>().ok().map(|n| format!("{}%", trim_num(n)));
    }
    free(v).map(|f| f.1)
}

/// `150` -> `150%` (filters, scale), arbitrary as is.
fn pct_num(v: &str) -> Option<String> {
    if v == "DEFAULT" {
        return Some("100%".into());
    }
    if let Ok(n) = v.parse::<f32>() {
        return Some(format!("{}%", trim_num(n)));
    }
    free(v).map(|f| f.1)
}

fn deg(v: &str) -> Option<String> {
    if let Ok(n) = v.parse::<f32>() {
        return Some(format!("{}deg", trim_num(n)));
    }
    free(v).map(|f| f.1)
}

fn leading(v: &str) -> Option<String> {
    if v == "none" {
        return Some("1".into());
    }
    if let Some(l) = theme(&format!("leading-{v}")) {
        return Some(l.into());
    }
    spacing(v)
}

fn radius(v: &str) -> Option<String> {
    match v {
        "DEFAULT" => Some("0.25rem".into()),
        "none" => Some("0".into()),
        "full" => Some("calc(infinity * 1px)".into()),
        _ => theme(&format!("radius-{v}")).map(String::from).or_else(|| free(v).map(|f| f.1)),
    }
}

fn border_width(v: &str) -> Option<String> {
    if let Ok(n) = v.parse::<f32>() {
        return Some(format!("{}px", trim_num(n)));
    }
    match free(v) {
        Some((Some(h), a)) if h == "length" || h == "line-width" => Some(a),
        Some((None, a)) if a.ends_with("px") || a.ends_with("rem") || a.ends_with("em") || a == "thin"
                           || a == "medium" || a == "thick" => Some(a),
        _ => None,
    }
}

fn dir_words(d: &str) -> Option<&'static str> {
    Some(match d {
        "t" => "top",
        "tr" => "top right",
        "r" => "right",
        "br" => "bottom right",
        "b" => "bottom",
        "bl" => "bottom left",
        "l" => "left",
        "tl" => "top left",
        _ => return None,
    })
}

fn position_kw(v: &str) -> Option<String> {
    Some(match v {
        "center" => "center",
        "top" => "top",
        "bottom" => "bottom",
        "left" => "left",
        "right" => "right",
        "top-left" | "left-top" => "left top",
        "top-right" | "right-top" => "right top",
        "bottom-left" | "left-bottom" => "left bottom",
        "bottom-right" | "right-bottom" => "right bottom",
        _ => return None,
    }.into())
}

fn align_kw(root: &str, v: &str) -> Option<String> {
    let base = v.trim_end_matches("-safe");
    let kw = match base {
        "start" => "flex-start",
        "end" => "flex-end",
        "center" => "center",
        "between" => "space-between",
        "around" => "space-around",
        "evenly" => "space-evenly",
        "stretch" => "stretch",
        "baseline" => "baseline",
        "baseline-last" => "last baseline",
        "normal" => "normal",
        "auto" => "auto",
        _ => return None,
    };
    // content alignment and flex item alignment use flex-start / flex-end;
    // justify-items, justify-self and place-items / place-self use start / end
    let kw = match (root, base) {
        ("justify-items" | "justify-self" | "place-items" | "place-self", "start") => "start",
        ("justify-items" | "justify-self" | "place-items" | "place-self", "end") => "end",
        _ => kw,
    };
    Some(if v.ends_with("-safe") { format!("safe {kw}") } else { kw.to_string() })
}

/// One variant: (new selector, wrapper at-rule, sort weight).
fn variant(v: &str, sel: &str) -> Option<(Option<String>, Option<String>, u32)> {
    let s = |suffix: &str| Some((Some(format!("{sel}{suffix}")), None, 10));
    let pseudo = |p: &str| -> Option<&'static str> {
        Some(match p {
            "hover" => ":hover",
            "focus" => ":focus",
            "focus-visible" => ":focus-visible",
            "focus-within" => ":focus-within",
            "active" => ":active",
            "visited" => ":visited",
            "target" => ":target",
            "first" => ":first-child",
            "last" => ":last-child",
            "only" => ":only-child",
            "odd" => ":nth-child(odd)",
            "even" => ":nth-child(even)",
            "first-of-type" => ":first-of-type",
            "last-of-type" => ":last-of-type",
            "only-of-type" => ":only-of-type",
            "empty" => ":empty",
            "disabled" => ":disabled",
            "enabled" => ":enabled",
            "checked" => ":checked",
            "indeterminate" => ":indeterminate",
            "default" => ":default",
            "optional" => ":optional",
            "required" => ":required",
            "valid" => ":valid",
            "invalid" => ":invalid",
            "user-valid" => ":user-valid",
            "user-invalid" => ":user-invalid",
            "in-range" => ":in-range",
            "out-of-range" => ":out-of-range",
            "placeholder-shown" => ":placeholder-shown",
            "autofill" => ":autofill",
            "read-only" => ":read-only",
            "read-write" => ":read-write",
            "open" => ":is([open], :popover-open, :open)",
            "inert" => ":is([inert], [inert] *)",
            "details-content" => "::details-content",
            _ => return None,
        })
    };
    if let Some(p) = pseudo(v) {
        return s(p);
    }
    let pe = |p: &str| -> Option<&'static str> {
        Some(match p {
            "before" => "::before",
            "after" => "::after",
            "placeholder" => "::placeholder",
            "file" => "::file-selector-button",
            "marker" => "::marker",
            "selection" => "::selection",
            "first-line" => "::first-line",
            "first-letter" => "::first-letter",
            "backdrop" => "::backdrop",
            _ => return None,
        })
    };
    if let Some(p) = pe(v) {
        return Some((Some(format!("{sel}{p}")), None, 60));
    }
    let bp = |name: &str| theme(&format!("breakpoint-{name}"));
    let media = |q: String, w: u32| Some((None, Some(format!("@media {q}")), w));
    match v {
        "*" => return Some((Some(format!(":is({sel} > *)")), None, 1)),
        "**" => return Some((Some(format!(":is({sel} *)")), None, 1)),
        "dark" => return media("(prefers-color-scheme: dark)".into(), 500),
        "motion-safe" => return media("(prefers-reduced-motion: no-preference)".into(), 300),
        "motion-reduce" => return media("(prefers-reduced-motion: reduce)".into(), 300),
        "contrast-more" => return media("(prefers-contrast: more)".into(), 300),
        "contrast-less" => return media("(prefers-contrast: less)".into(), 300),
        "print" => return media("print".into(), 510),
        "portrait" => return media("(orientation: portrait)".into(), 300),
        "landscape" => return media("(orientation: landscape)".into(), 300),
        "forced-colors" => return media("(forced-colors: active)".into(), 300),
        "inverted-colors" => return media("(inverted-colors: inverted)".into(), 300),
        "pointer-fine" => return media("(pointer: fine)".into(), 300),
        "pointer-coarse" => return media("(pointer: coarse)".into(), 300),
        "pointer-none" => return media("(pointer: none)".into(), 300),
        "any-pointer-fine" => return media("(any-pointer: fine)".into(), 300),
        "any-pointer-coarse" => return media("(any-pointer: coarse)".into(), 300),
        "noscript" => return media("(scripting: none)".into(), 300),
        "rtl" => return Some((Some(format!("{sel}:where(:dir(rtl), [dir=rtl], [dir=rtl] *)")), None, 20)),
        "ltr" => return Some((Some(format!("{sel}:where(:dir(ltr), [dir=ltr], [dir=ltr] *)")), None, 20)),
        "starting" => return Some((None, Some("@starting-style".into()), 600)),
        _ => {}
    }
    // breakpoints: sm md lg xl 2xl (ascending weight so larger wins), max-*, min-[..]
    for (k, name) in ["sm", "md", "lg", "xl", "2xl"].iter().enumerate() {
        if v == *name {
            return media(format!("(width >= {})", bp(name)?), 400 + k as u32 * 2);
        }
        if v.strip_prefix("max-") == Some(name) {
            return media(format!("(width < {})", bp(name)?), 399 - k as u32 * 2);
        }
    }
    if let Some(a) = v.strip_prefix("min-").and_then(arbitrary) {
        return media(format!("(width >= {a})"), 420);
    }
    if let Some(a) = v.strip_prefix("max-").and_then(arbitrary) {
        return media(format!("(width < {a})"), 380);
    }
    // container queries: @sm, @max-md, @min-[..], @[..], @md/name
    if let Some(c) = v.strip_prefix('@') {
        let (c, name) = match c.split_once('/') {
            Some((c, n)) => (c, format!("{n} ")),
            None => (c, String::new()),
        };
        let (op, size_name) = match c.strip_prefix("max-") {
            Some(r) => ("<", r),
            None => (">=", c.strip_prefix("min-").unwrap_or(c)),
        };
        let size = match arbitrary(size_name) {
            Some(a) => a,
            None => theme(&format!("container-{size_name}"))?.to_string(),
        };
        return Some((None, Some(format!("@container {name}(width {op} {size})")), 450));
    }
    // supports-[..], supports-grid
    if let Some(rest) = v.strip_prefix("supports-") {
        let cond = match arbitrary(rest) {
            Some(a) if a.contains(':') || a.starts_with('(') => if a.starts_with('(') { a } else { format!("({a})") },
            Some(a) => format!("({a}: var(--tw))"),
            None => format!("(display: {rest})"),
        };
        return Some((None, Some(format!("@supports {cond}")), 350));
    }
    // arbitrary variant [&>p] / [@media(...)]
    if v.starts_with('[') {
        let a = arbitrary(v)?;
        if a.starts_with('@') {
            return Some((None, Some(a), 700));
        }
        return Some((Some(if a.contains('&') { a.replace('&', sel) } else { format!("{sel}{a}") }), None, 30));
    }
    // data-*, aria-*
    if let Some(d) = v.strip_prefix("data-") {
        let attr = match arbitrary(d) {
            Some(a) => format!("[data-{a}]"),
            None => format!("[data-{d}]"),
        };
        return s(&attr);
    }
    if let Some(d) = v.strip_prefix("aria-") {
        let attr = match arbitrary(d) {
            Some(a) => format!("[aria-{a}]"),
            None => format!("[aria-{d}=\"true\"]"),
        };
        return s(&attr);
    }
    // nth-*
    for (name, pc) in [("nth-last-of-type-", "nth-last-of-type"), ("nth-of-type-", "nth-of-type"),
                       ("nth-last-", "nth-last-child"), ("nth-", "nth-child")] {
        if let Some(n) = v.strip_prefix(name) {
            let n = arbitrary(n).unwrap_or_else(|| n.to_string());
            return s(&format!(":{pc}({n})"));
        }
    }
    // group-*, peer-* (optionally named: group-hover/item), has-*, not-*, in-*
    let inner_sel = |x: &str| -> Option<String> {
        if let Some(p) = pseudo(x) {
            return Some(p.to_string());
        }
        if let Some(a) = arbitrary(x) {
            return Some(if a.contains('&') { a.replace('&', "") } else { a });
        }
        if let Some(d) = x.strip_prefix("data-") {
            return Some(arbitrary(d).map(|a| format!("[data-{a}]")).unwrap_or_else(|| format!("[data-{d}]")));
        }
        if let Some(d) = x.strip_prefix("aria-") {
            return Some(arbitrary(d).map(|a| format!("[aria-{a}]")).unwrap_or_else(|| format!("[aria-{d}=\"true\"]")));
        }
        if let Some(h) = x.strip_prefix("has-") {
            let hs = pseudo(h).map(|p| format!("*{p}")).or_else(|| arbitrary(h))?;
            return Some(format!(":has({hs})"));
        }
        None
    };
    for (prefix, comb) in [("group-", " "), ("peer-", " ~ ")] {
        if let Some(rest) = v.strip_prefix(prefix) {
            let (state, name) = match rest.rsplit_once('/') {
                Some((s, n)) if !s.contains('[') || s.ends_with(']') => (s, format!("\\/{n}")),
                _ => (rest, String::new()),
            };
            let which = &prefix[..prefix.len() - 1];
            let st = inner_sel(state)?;
            return Some((Some(format!(":where(.{which}{name}){st}{comb}{sel}")), None, 40));
        }
    }
    if let Some(rest) = v.strip_prefix("has-") {
        let x = pseudo(rest).map(|p| format!("*{p}")).or_else(|| arbitrary(rest))?;
        return s(&format!(":has({x})"));
    }
    if let Some(rest) = v.strip_prefix("not-") {
        let x = inner_sel(rest)?;
        return s(&format!(":not({x})"));
    }
    if let Some(rest) = v.strip_prefix("in-") {
        let x = inner_sel(rest)?;
        return Some((Some(format!(":where(*{x}) {sel}")), None, 40));
    }
    None
}

/// Rank of a property in Tailwind's utility order: earlier properties
/// come first; shorthands before their longhands.
fn prop_rank(p: &str) -> u32 {
    const ORDER: &[&str] = &[
        "container-type", "pointer-events", "visibility", "position", "inset", "top", "right", "bottom", "left",
        "isolation", "z-index", "order", "grid-column", "grid-row", "float", "clear", "box-sizing", "margin",
        "display", "aspect-ratio", "width", "min-width", "max-width", "height", "min-height", "max-height",
        "flex", "flex-shrink", "flex-grow", "flex-basis", "table-layout", "caption-side", "border-collapse",
        "border-spacing", "transform-origin", "translate", "scale", "rotate", "transform", "animation", "cursor",
        "touch-action", "resize", "scroll-snap-type", "scroll-snap-align", "scroll-margin", "scroll-padding",
        "list-style-position", "list-style-type", "appearance", "columns", "grid-auto-columns", "grid-auto-flow",
        "grid-auto-rows", "grid-template-columns", "grid-template-rows", "flex-direction", "flex-wrap",
        "place-content", "place-items", "align-content", "align-items", "justify-content", "justify-items", "gap",
        "column-gap", "row-gap", "place-self", "align-self", "justify-self", "overflow", "overscroll-behavior",
        "scroll-behavior", "text-overflow", "white-space", "word-break", "border-radius", "border-width",
        "border-style", "border-color", "background-color", "background-image", "--tw-gradient-from",
        "--tw-gradient-via", "--tw-gradient-to", "background-size", "background-attachment", "background-clip",
        "background-position", "background-repeat", "background-origin", "fill", "stroke", "object-fit",
        "object-position", "padding", "text-align", "text-indent", "vertical-align", "font-family", "font-size",
        "line-height", "font-weight", "letter-spacing", "text-wrap", "overflow-wrap", "hyphens", "color",
        "text-transform", "font-style", "text-decoration-line", "text-decoration-color", "text-decoration-style",
        "text-decoration-thickness", "text-underline-offset", "opacity", "mix-blend-mode", "box-shadow",
        "outline", "filter", "backdrop-filter", "transition-property", "transition-delay", "transition-duration",
        "transition-timing-function", "will-change", "content",
    ];
    let base = p.split('-').take(2).collect::<Vec<_>>().join("-");
    let idx = ORDER.iter().position(|o| *o == p)
        .or_else(|| ORDER.iter().position(|o| *o == base))
        .or_else(|| ORDER.iter().position(|o| p.starts_with(o)))
        .unwrap_or(ORDER.len());
    idx as u32 * 8 + p.matches('-').count() as u32
}

#[cfg(test)]
mod tests {
    use super::*;

    fn body(class: &str) -> String {
        compile(class).unwrap_or_else(|| panic!("{class}")).css
    }

    #[test]
    fn utilities() {
        assert!(body("p-4").contains("padding: calc(0.25rem * 4)"));
        assert!(body("px-2.5").contains("padding-inline: calc(0.25rem * 2.5)"));
        assert!(body("-mt-8").contains("margin-top: calc(calc(0.25rem * 8) * -1)"));
        assert!(body("w-1/2").contains("width: 50%"));
        assert!(body("w-[calc(100%-2rem)]").contains("width: calc(100%-2rem)"));
        assert!(body("bg-sky-500/50").contains("color-mix(in oklab, oklch(68.5% 0.169 237.323) 50%, transparent)"));
        assert!(body("bg-(--brand)").contains("background-color: var(--brand)"));
        assert!(body("text-lg").contains("font-size: 1.125rem"));
        assert!(body("text-sm/6").contains("line-height: calc(0.25rem * 6)"));
        assert!(body("text-red-500").contains("color: oklch(63.7% 0.237 25.331)"));
        assert!(body("rounded-xl").contains("border-radius: 0.75rem"));
        assert!(body("grid-cols-3").contains("repeat(3, minmax(0, 1fr))"));
        assert!(body("shadow-lg").contains("box-shadow: 0 10px 15px -3px"));
        assert!(body("[mask-type:luminance]").contains("mask-type: luminance"));
        assert!(body("bg-linear-to-r").contains("linear-gradient(to right"));
        assert!(body("animate-spin").contains("@keyframes spin"));
        assert!(body("font-bold").contains("font-weight: 700"));
        assert!(body("border").contains("border-width: 1px"));
        assert!(body("p-4!").contains("!important"));
        assert!(compile("not-a-utility").is_none());
        assert!(compile("p-banana").is_none());
    }

    #[test]
    fn variants() {
        assert!(body("hover:bg-red-500").contains(".hover\\:bg-red-500:hover {"));
        assert!(body("md:flex").contains("@media (width >= 48rem)"));
        assert!(body("dark:md:hover:underline").contains("@media (prefers-color-scheme: dark)"));
        assert!(body("group-hover:text-white").contains(":where(.group):hover .group-hover\\:text-white"));
        assert!(body("group-hover/item:p-1").contains(":where(.group\\/item):hover"));
        assert!(body("peer-checked:block").contains(":where(.peer):checked ~ "));
        assert!(body("has-checked:ring-2").contains(":has(*:checked)"));
        assert!(body("data-[state=open]:p-2").contains("[data-state=open]"));
        assert!(body("aria-expanded:p-2").contains("[aria-expanded=\"true\"]"));
        assert!(body("*:p-2").contains(":is(.\\*\\:p-2 > *)"));
        assert!(body("[&>p]:mt-2").contains(r".\[\&\>p\]\:mt-2>p"));
        assert!(body("@md:grid").contains("@container (width >= 28rem)"));
        assert!(body("before:block").contains("::before { content: ''; display: block"));
        assert!(body("max-md:hidden").contains("(width < 48rem)"));
        assert!(compile("md:p-banana").is_none());
        assert!(compile("wat:p-4").is_none());
        // larger breakpoints sort after smaller ones, variants after base utilities
        assert!(compile("lg:p-1").unwrap().sort > compile("md:p-1").unwrap().sort);
        assert!(compile("p-1").unwrap().sort < compile("hover:p-1").unwrap().sort);
        assert!(compile("p-1").unwrap().sort < compile("px-1").unwrap().sort);
    }
}

// ==========================================================================
// Suggestions ("did you mean ...?")

/// Variant names for suggestions (functional ones by prefix).
const VARIANTS: &[&str] = &[
    "hover", "focus", "focus-visible", "focus-within", "active", "visited", "target", "first", "last", "only",
    "odd", "even", "first-of-type", "last-of-type", "only-of-type", "empty", "disabled", "enabled", "checked",
    "indeterminate", "default", "optional", "required", "valid", "invalid", "user-valid", "user-invalid",
    "in-range", "out-of-range", "placeholder-shown", "autofill", "read-only", "read-write", "open", "inert",
    "before", "after", "placeholder", "file", "marker", "selection", "first-line", "first-letter", "backdrop",
    "sm", "md", "lg", "xl", "2xl", "max-sm", "max-md", "max-lg", "max-xl", "max-2xl", "@sm", "@md", "@lg",
    "@xl", "@2xl", "dark", "motion-safe", "motion-reduce", "contrast-more", "contrast-less", "print",
    "portrait", "landscape", "forced-colors", "rtl", "ltr", "starting", "*", "**", "group-hover", "group-focus",
    "group-active", "peer-hover", "peer-focus", "peer-checked", "peer-invalid", "has-checked", "not-first",
    "pointer-fine", "pointer-coarse",
];

fn distance(a: &str, b: &str) -> usize {
    let (a, b): (Vec<char>, Vec<char>) = (a.chars().collect(), b.chars().collect());
    let mut prev: Vec<usize> = (0..=b.len()).collect();
    for i in 1..=a.len() {
        let mut cur = vec![i; b.len() + 1];
        for j in 1..=b.len() {
            let cost = usize::from(a[i - 1] != b[j - 1]);
            cur[j] = (prev[j] + 1).min(cur[j - 1] + 1).min(prev[j - 1] + cost);
        }
        prev = cur;
    }
    prev[b.len()]
}

/// Values worth trying after a root: theme keys and the common scales.
fn value_candidates() -> Vec<String> {
    let mut v: Vec<String> = THEME.iter().filter_map(|(k, _)| {
        ["color-", "text-", "radius-", "shadow-", "blur-", "font-weight-", "tracking-", "leading-",
         "breakpoint-", "container-", "drop-shadow-", "inset-shadow-", "text-shadow-", "perspective-"]
            .iter().find_map(|p| k.strip_prefix(p)).filter(|r| !r.contains("--")).map(String::from)
    }).collect();
    for n in ["0", "0.5", "1", "1.5", "2", "2.5", "3", "3.5", "4", "5", "6", "7", "8", "9", "10", "11", "12",
              "14", "16", "20", "24", "28", "32", "36", "40", "44", "48", "52", "56", "60", "64", "72", "80",
              "96", "px", "auto", "full", "screen", "min", "max", "fit", "none", "1/2", "1/3", "2/3", "1/4",
              "3/4", "sans", "serif", "mono", "left", "center", "right", "start", "end", "between", "around",
              "evenly", "stretch", "baseline", "row", "col", "wrap", "nowrap", "black", "white", "transparent",
              "current", "inherit", "50", "75", "90", "95", "100", "105", "110", "125", "150", "45", "90", "180"] {
        v.push(n.to_string());
    }
    v.sort();
    v.dedup();
    v
}

/// Valid classes close to `class` (best first, at most 3): misspelled
/// variants, roots, values or whole utilities.
pub fn suggest(class: &str) -> Vec<String> {
    let Some(parts) = split_variants(class) else { return Vec::new() };
    let (vars, util) = parts.split_at(parts.len() - 1);
    let util = util[0];
    // each variant: itself when valid, else its nearest names
    let mut var_options: Vec<Vec<String>> = Vec::new();
    for v in vars {
        if variant(v, ".x").is_some() {
            var_options.push(vec![v.to_string()]);
        } else {
            let mut near: Vec<&str> = VARIANTS.to_vec();
            near.sort_by_key(|n| distance(v, n));
            var_options.push(near.into_iter().take(2).map(String::from).collect());
        }
    }
    // the utility: itself when valid, else candidates
    let utils: Vec<String> = if utility_decls(util.trim_matches('!')).is_some() {
        vec![util.to_string()]
    } else {
        let (neg, body) = match util.strip_prefix('-') {
            Some(b) => ("-", b),
            None => ("", util),
        };
        let mut c: Vec<String> = STATIC.iter().map(|(n, _)| n.to_string()).collect();
        let values = value_candidates();
        let dashes: Vec<usize> = body.char_indices().filter(|(_, ch)| *ch == '-').map(|(k, _)| k).collect();
        for &k in &dashes {
            let (root, val) = (&body[..k], &body[k + 1..]);
            for r in ROOTS {
                c.push(format!("{neg}{r}-{val}")); // fix the root
            }
            for v in &values {
                c.push(format!("{neg}{root}-{v}")); // fix the value
            }
        }
        if dashes.is_empty() {
            for r in ROOTS {
                c.push(format!("{neg}{r}"));
            }
        }
        c.retain(|x| utility_decls(x).is_some());
        c.sort_by_key(|x| (distance(util, x), x.len().abs_diff(util.len())));
        c.dedup();
        c.into_iter().take(3).collect()
    };
    // combine (variants x utilities), keep what compiles, closest first
    let mut out: Vec<String> = vec![String::new()];
    for opts in var_options.iter().chain(std::iter::once(&utils)) {
        out = out.iter().flat_map(|p| opts.iter().map(move |o| if p.is_empty() { o.clone() } else { format!("{p}:{o}") }))
            .collect();
    }
    out.retain(|x| x != class && compile(x).is_some());
    out.sort_by_key(|x| (distance(class, x), x.len().abs_diff(class.len())));
    out.dedup();
    out.truncate(3);
    out
}

/// A compile-time error message for an unknown class.
pub fn unknown_message(class: &str) -> String {
    let s = suggest(class);
    if s.is_empty() {
        format!("`{class}` is not a Tailwind utility")
    } else {
        format!("`{class}` is not a Tailwind utility; did you mean {}?",
                s.iter().map(|x| format!("`{x}`")).collect::<Vec<_>>().join(" or "))
    }
}

#[cfg(test)]
mod suggest_tests {
    use super::*;

    #[test]
    fn did_you_mean() {
        assert_eq!(suggest("bg-sky-50O").first().map(String::as_str), Some("bg-sky-500"));
        assert_eq!(suggest("bgg-red-500").first().map(String::as_str), Some("bg-red-500"));
        assert_eq!(suggest("hovr:p-4").first().map(String::as_str), Some("hover:p-4"));
        assert_eq!(suggest("flx").first().map(String::as_str), Some("flex"));
        assert_eq!(suggest("itms-center").first().map(String::as_str), Some("items-center"));
        assert!(unknown_message("roundd-lg").contains("`rounded-lg`"));
    }
}