Skip to main content

parsec_css/
microsyntax.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright 2026 James Conway
3
4//! The two microsyntaxes CSS Syntax defines over tokens: An+B, for
5//! `:nth-child()`, and `<urange>`, for `@font-face`'s `unicode-range`.
6
7use crate::parser::{ComponentValue, parse_component_values, parse_unicode_range_value};
8use crate::tokenizer::{Number, Token};
9
10/// Reads An+B from a list of component values: `(A, B)`, or `None` if
11/// they aren't An+B. Values beyond `i32` saturate.
12///
13/// ```
14/// assert_eq!(parsec_css::parse_anb("2n+1"), Some((2, 1)));
15/// assert_eq!(parsec_css::parse_anb(" -n- 3 "), Some((-1, -3)));
16/// assert_eq!(parsec_css::parse_anb("+ 2n"), None);
17/// ```
18pub fn anb(values: &[ComponentValue<'_>]) -> Option<(i32, i32)> {
19    let mut rest = values.iter();
20    let skip_ws = |it: &mut std::slice::Iter<'_, ComponentValue<'_>>| {
21        while it
22            .as_slice()
23            .first()
24            .is_some_and(ComponentValue::is_whitespace)
25        {
26            it.next();
27        }
28    };
29    skip_ws(&mut rest);
30    let first = rest.next()?.token()?;
31    let result = match first {
32        Token::Number(n) if n.integer => (0, n.int()),
33        Token::Ident(v) => match v.to_ascii_lowercase().as_str() {
34            "odd" => (2, 1),
35            "even" => (2, 0),
36            s => match s.strip_prefix('-') {
37                Some(s) => after_n(-1, s, &mut rest)?,
38                None => after_n(1, s, &mut rest)?,
39            },
40        },
41        Token::Dimension { number, unit } if number.integer => {
42            after_n(number.int(), &unit.to_ascii_lowercase(), &mut rest)?
43        }
44        // `+n…`, with nothing between the `+` and the `n`.
45        Token::Delim('+') => match rest.next()?.token()? {
46            Token::Ident(v) if !v.starts_with('-') => {
47                after_n(1, &v.to_ascii_lowercase(), &mut rest)?
48            }
49            _ => return None,
50        },
51        _ => return None,
52    };
53    skip_ws(&mut rest);
54    rest.next().is_none().then_some(result)
55}
56
57/// The rest of An+B once A is known; `n` is what followed A, lowercased:
58/// `n`, `n-` or `n-` and digits.
59fn after_n(
60    a: i32,
61    n: &str,
62    rest: &mut std::slice::Iter<'_, ComponentValue<'_>>,
63) -> Option<(i32, i32)> {
64    let signless = |t: Option<&Token<'_>>| match t {
65        Some(Token::Number(n)) if n.integer && n.sign().is_none() => Some(n.int()),
66        _ => None,
67    };
68    match n {
69        "n" => {
70            let mut look = rest.clone();
71            match next_solid(&mut look) {
72                None => Some((a, 0)),
73                Some(Token::Number(n @ Number { integer: true, .. })) if n.sign().is_some() => {
74                    *rest = look;
75                    Some((a, n.int()))
76                }
77                Some(&Token::Delim(sign @ ('+' | '-'))) => {
78                    let b = signless(next_solid(&mut look))?;
79                    *rest = look;
80                    Some((a, if sign == '-' { b.saturating_neg() } else { b }))
81                }
82                _ => None,
83            }
84        }
85        "n-" => {
86            let b = signless(next_solid(rest))?;
87            Some((a, b.saturating_neg()))
88        }
89        _ => {
90            let digits = n.strip_prefix("n-")?;
91            if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
92                return None;
93            }
94            let b: f64 = digits.parse().ok()?;
95            Some((a, -(b as i32)))
96        }
97    }
98}
99
100fn next_solid<'t, 'a>(it: &mut std::slice::Iter<'t, ComponentValue<'a>>) -> Option<&'t Token<'a>> {
101    it.find(|v| !v.is_whitespace())
102        .and_then(ComponentValue::token)
103}
104
105/// [`anb`] over CSS text.
106pub fn parse_anb(css: &str) -> Option<(i32, i32)> {
107    anb(&parse_component_values(css))
108}
109
110/// Writes An+B the way CSS Syntax serializes it: `2n+1`, `-n`, `5`.
111pub fn serialize_anb(a: i32, b: i32) -> String {
112    if a == 0 {
113        return b.to_string();
114    }
115    let mut out = match a {
116        1 => "n".to_string(),
117        -1 => "-n".to_string(),
118        _ => format!("{a}n"),
119    };
120    if b > 0 {
121        out.push('+');
122    }
123    if b != 0 {
124        out.push_str(&b.to_string());
125    }
126    out
127}
128
129/// A `<urange>` from CSS Fonts: the code points `start..=end`.
130#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
131pub struct UnicodeRange {
132    pub start: u32,
133    pub end: u32,
134}
135
136/// Reads a `unicode-range` descriptor's comma-separated `<urange>`s. Each
137/// is `None` if it isn't one range, or its range is backwards or past
138/// U+10FFFF.
139///
140/// ```
141/// use parsec_css::{UnicodeRange, parse_unicode_ranges};
142///
143/// let ranges = parse_unicode_ranges("U+0-7F, u+4??, U+5-1");
144/// assert_eq!(ranges[0], Some(UnicodeRange { start: 0, end: 0x7f }));
145/// assert_eq!(ranges[1], Some(UnicodeRange { start: 0x400, end: 0x4ff }));
146/// assert_eq!(ranges[2], None);
147/// ```
148pub fn parse_unicode_ranges(css: &str) -> Vec<Option<UnicodeRange>> {
149    let values = parse_unicode_range_value(css);
150    values
151        .split(|v| v.token() == Some(&Token::Comma))
152        .map(|group| {
153            let mut solid = group.iter().filter(|v| !v.is_whitespace());
154            match (solid.next().and_then(ComponentValue::token), solid.next()) {
155                (Some(&Token::UnicodeRange { start, end }), None)
156                    if start <= end && end <= 0x10ffff =>
157                {
158                    Some(UnicodeRange { start, end })
159                }
160                _ => None,
161            }
162        })
163        .collect()
164}
165
166#[cfg(test)]
167mod tests {
168    use super::*;
169
170    #[test]
171    fn serializes_anb() {
172        for (a, b, s) in [(0, 5, "5"), (1, 0, "n"), (-1, 3, "-n+3"), (2, -1, "2n-1")] {
173            assert_eq!(serialize_anb(a, b), s);
174            assert_eq!(parse_anb(s), Some((a, b)));
175        }
176    }
177}