//! Numeric serialization for Typed OM values and CSS token streams. //! //! A CSS numeric value uses CSSOM formatting; raw number/dimension tokens need //! round-trippable double precision and must retain their lexical token type. use cssparser::{ToCss, Token, serialize_identifier}; use std::fmt::{self, Write}; /// CSSOM's browser-compatible six-significant-digit numeric representation. /// Rust's exponent formatter rounds ties to even, without first scaling the /// double (which could overflow, underflow, or introduce another rounding). /// Non-finite values use CSS math keywords; callers must put them in calc(). pub fn serialize_css_number(value: f64) -> String { if !value.is_finite() { return if value.is_nan() { "NaN" } else if value.is_sign_negative() { "-infinity" } else { "infinity" } .to_owned(); } if value == 0.0 { return "0".to_owned(); } let rounded = format!("{value:.5e}"); let (mantissa, exponent) = rounded.split_once('e').expect("exponent notation"); let exponent: i32 = exponent.parse().expect("numeric exponent"); if !(-4..6).contains(&exponent) { return format!( "{}e{exponent:+03}", mantissa.trim_end_matches('0').trim_end_matches('.') ); } let negative = mantissa.starts_with('-'); let digits = mantissa.trim_start_matches('-').replace('.', ""); let point = exponent + 1; let mut output = if negative { "-".to_owned() } else { String::new() }; if point <= 0 { output.push_str("0."); output.extend(std::iter::repeat_n('0', (-point) as usize)); output.push_str(&digits); } else { let point = point as usize; output.push_str(&digits[..point]); if point < digits.len() { output.push('.'); output.push_str(&digits[point..]); } } if output.contains('.') { output.truncate(output.trim_end_matches('0').trim_end_matches('.').len()); } output } // CSSParserToken in Chromium retains double precision but bounds the numeric // range by f32::MAX. The source slice matters: cssparser's Token stores f32 // values and saturates its integer field at i32 boundaries. pub fn css_numeric_token_value(token: &Token<'_>, source: &str) -> Option { let number = numeric_source(token, source)?.parse::().ok()?; Some(number.clamp(-f64::from(f32::MAX), f64::from(f32::MAX))) } fn numeric_source<'a>(token: &Token<'_>, source: &'a str) -> Option<&'a str> { match token { Token::Number { .. } => Some(source), Token::Percentage { .. } => source.strip_suffix('%'), Token::Dimension { .. } => { // The tokenizer already validated the number. Find the boundary // without consuming the e in a unit such as em; escaped units are // handled by the original token rather than by slicing its name. let bytes = source.as_bytes(); let mut end = usize::from(matches!(bytes.first(), Some(b'+' | b'-'))); while bytes.get(end).is_some_and(u8::is_ascii_digit) { end += 1; } if bytes.get(end) == Some(&b'.') { end += 1; while bytes.get(end).is_some_and(u8::is_ascii_digit) { end += 1; } } if matches!(bytes.get(end), Some(b'e' | b'E')) { let mut exponent = end + 1; if matches!(bytes.get(exponent), Some(b'+' | b'-')) { exponent += 1; } if bytes.get(exponent).is_some_and(u8::is_ascii_digit) { end = exponent + 1; while bytes.get(end).is_some_and(u8::is_ascii_digit) { end += 1; } } } Some(&source[..end]) } _ => None, } } /// Serialize one tokenizer-produced token with its exact consumed source slice. /// The caller owns token boundaries and insertion of any required separators. pub fn serialize_css_token(token: &Token<'_>, source: &str, output: &mut String) -> fmt::Result { let Some(value) = css_numeric_token_value(token, source) else { return token.to_css(output); }; match token { Token::Number { .. } => { if !source.contains(['.', 'e', 'E']) { // Match the browser's integer-token range, retaining values // beyond i32 without silently making an integer token a float. write!(output, "{}", value as i64)?; } else { let text = shortest_number(value); output.push_str(&text); if !text.contains(['.', 'e']) { output.push_str(".0"); } } } Token::Percentage { .. } => { output.push_str(&serialize_css_number(value)); output.push('%'); } Token::Dimension { unit, .. } => { output.push_str(&shortest_number(value)); // A decoded unit such as e2 would turn 4e3e2 into a number token // (4000e2). Escape its leading e so re-tokenizing preserves both // the numeric value and the dimension type. let bytes = unit.as_bytes(); let ambiguous = matches!(bytes.first(), Some(b'e' | b'E')) && (bytes.get(1).is_some_and(u8::is_ascii_digit) || (matches!(bytes.get(1), Some(b'+' | b'-')) && bytes.get(2).is_some_and(u8::is_ascii_digit))); if ambiguous { output.push_str(if bytes[0] == b'e' { "\\65 " } else { "\\45 " }); cssparser::serialize_name(&unit[1..], output)?; } else { serialize_identifier(unit, output)?; } } _ => unreachable!("numeric token projection"), } Ok(()) } fn shortest_number(value: f64) -> String { if value == 0.0 { return "0".to_owned(); } let magnitude = value.abs(); let plain = value.to_string(); if (1e-6..1e21).contains(&magnitude) { return plain; } let unsigned = plain.trim_start_matches('-'); let point = unsigned.find('.').unwrap_or(unsigned.len()); let digits = unsigned.replace('.', ""); let significant = digits.trim_start_matches('0'); let exponent = point as i32 - (digits.len() - significant.len()) as i32 - 1; let significant = significant.trim_end_matches('0'); let mut output = if value.is_sign_negative() { "-".to_owned() } else { String::new() }; output.push_str(&significant[..1]); if significant.len() > 1 { output.push('.'); output.push_str(&significant[1..]); } write!(&mut output, "e{exponent:+}").expect("String writes cannot fail"); output } #[cfg(test)] mod tests { use super::*; use cssparser::Parser; fn serialize(source: &str) -> String { let input = source; let mut parser = Parser::new(input); let token = parser.next().unwrap().clone(); let mut result = String::new(); serialize_css_token(&token, source, &mut result).unwrap(); result } #[test] fn css_number_serialization_rounds_once_and_preserves_the_full_double_range() { for (number, expected) in [ (-0.0, "0"), (0.031400000000000004, "0.0314"), (1.234565, "1.23456"), (-1.234565, "-1.23456"), (999999.4, "999999"), (999999.5, "1e+06"), (0.0001, "0.0001"), (0.00001, "1e-05"), (f64::MAX, "1.79769e+308"), (f64::from_bits(1), "4.94066e-324"), (f64::INFINITY, "infinity"), (f64::NEG_INFINITY, "-infinity"), (f64::NAN, "NaN"), ] { assert_eq!(serialize_css_number(number), expected, "{number:?}"); } } #[test] fn css_numeric_tokens_retain_precision_and_their_integer_or_number_type() { for (source, expected) in [ ("0.123456789123456789px", "0.12345678912345678px"), ("0.123456789123456789", "0.12345678912345678"), ("0.123456789123456789%", "0.123457%"), ("+01.2300e+2px", "123px"), ("+01.2300e+2", "123.0"), ("-0", "0"), ("-0.0", "0.0"), ("-0px", "0px"), ("+0.0%", "0%"), ("2147483648", "2147483648"), ("9223372036854775808", "9223372036854775807"), ("1e100", "3.4028234663852886e+38"), ("1e1000px", "3.4028234663852886e+38px"), ("1e1000%", "3.40282e+38%"), ("1e-999px", "0px"), ("1e-7px", "1e-7px"), ("1e-6px", "0.000001px"), ("1e21px", "1e+21px"), ("1em", "1em"), ("1e2em", "100em"), ("1p\\78", "1px"), ] { assert_eq!(serialize(source), expected, "{source}"); } } #[test] fn dimension_serialization_does_not_turn_a_unit_into_an_exponent() { for (source, unit, number) in [ ("4e3e2", "e2", 4000.0), ("4e3\\65 2", "e2", 4000.0), ("1\\45 -2", "E-2", 1.0), ("1e21e2", "e2", 1e21), ("-2\\65 -foo", "e-foo", -2.0), ] { let text = serialize(source); let input = &text; let mut parser = Parser::new(input); let token = parser.next().unwrap().clone(); assert!( matches!(&token, Token::Dimension { unit: parsed, .. } if parsed.as_ref() == unit), "{source}: {text}" ); assert_eq!(css_numeric_token_value(&token, &text), Some(number)); parser.expect_exhausted().unwrap(); assert_eq!(serialize(&text), text, "serialization must be idempotent"); } } }