parsec_css/
microsyntax.rs1use crate::parser::{ComponentValue, parse_component_values, parse_unicode_range_value};
8use crate::tokenizer::{Number, Token};
9
10pub 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 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
57fn 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
105pub fn parse_anb(css: &str) -> Option<(i32, i32)> {
107 anb(&parse_component_values(css))
108}
109
110pub 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#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
131pub struct UnicodeRange {
132 pub start: u32,
133 pub end: u32,
134}
135
136pub 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}