use super::css_properties::CSS_PROPERTY_TRAITS;
use crate::json::number_to_string;
use crate::set_dom_style::{css_declarations, js_trim};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct CssPropertyTraits(pub u8);
impl CssPropertyTraits {
pub const COLOR: u8 = 1;
pub const ZERO_LENGTH: u8 = 2;
pub const PRESERVE_CASE: u8 = 4;
pub const VERBATIM: u8 = 8;
fn has(self, bit: u8) -> bool {
self.0 & bit != 0
}
}
pub fn css_property_traits(name: &str) -> Option<CssPropertyTraits> {
CSS_PROPERTY_TRAITS
.binary_search_by(|(n, _)| (*n).cmp(name))
.ok()
.map(|i| CssPropertyTraits(CSS_PROPERTY_TRAITS[i].1))
}
pub fn css_property_names() -> impl Iterator<Item = &'static str> {
CSS_PROPERTY_TRAITS.iter().map(|(n, _)| *n)
}
pub(crate) fn preprocess_css(css: &str) -> String {
if !css.contains(['\u{0C}', '\r', '\0']) && !css.ends_with('\\') {
return css.to_owned();
}
let mut chars: Vec<char> = css.chars().collect();
if chars.last() == Some(&'\\') {
*chars.last_mut().expect("a last char") = '\u{FFFD}';
}
let mut out = String::with_capacity(css.len());
let mut i = 0;
while i < chars.len() {
match chars[i] {
'\u{0C}' => out.push('\n'),
'\r' => {
out.push('\n');
if chars.get(i + 1) == Some(&'\n') {
i += 1;
}
}
'\0' => out.push('\u{FFFD}'),
c => out.push(c),
}
i += 1;
}
out
}
pub(crate) fn parse_css_declarations(css: &str) -> Vec<(String, String)> {
css_declarations(css)
}
pub(crate) fn normalize_css_value(name: &str, value: &str) -> Option<String> {
if name.starts_with("--") {
let trimmed = js_trim(value);
return (!trimmed.is_empty()).then(|| trimmed.to_owned());
}
let traits = css_property_traits(name)?;
let trimmed = js_trim(value);
if CSS_WIDE_KEYWORDS
.iter()
.any(|k| trimmed.eq_ignore_ascii_case(k))
{
return Some(trimmed.to_ascii_lowercase());
}
if traits.has(CssPropertyTraits::VERBATIM) {
if trimmed.eq_ignore_ascii_case("none") {
return Some("none".to_owned());
}
let only_identifiers = tokenize_css_value(trimmed).iter().all(|t| match t {
Token::Word(word) => {
word.chars()
.next()
.is_some_and(|c| c.is_alphabetic() || c == '_')
&& !word.contains('(')
}
Token::Comma => true,
});
if only_identifiers {
return None;
}
}
let mut out = String::new();
let mut needs_space = false;
for token in tokenize_css_value(value) {
match token {
Token::Comma => {
out.push(',');
needs_space = true;
}
Token::Word(word) => {
if needs_space || !out.is_empty() {
out.push(' ');
}
needs_space = false;
if traits.has(CssPropertyTraits::VERBATIM) {
out.push_str(&word);
} else {
out.push_str(&normalize_css_word(&word, traits));
}
}
}
}
(!out.is_empty()).then_some(out)
}
pub(crate) const CSS_WIDE_KEYWORDS: &[&str] =
&["initial", "inherit", "unset", "revert", "revert-layer"];
enum Token {
Word(String),
Comma,
}
fn tokenize_css_value(value: &str) -> Vec<Token> {
let mut tokens = Vec::new();
let mut word = String::new();
let mut depth = 0usize;
let mut quote: Option<char> = None;
let mut escaped = false;
let flush = |word: &mut String, tokens: &mut Vec<Token>| {
if !word.is_empty() {
tokens.push(Token::Word(std::mem::take(word)));
}
};
for c in value.chars() {
if let Some(current) = quote {
word.push(c);
if escaped {
escaped = false;
} else if c == '\\' {
escaped = true;
} else if c == current {
quote = None;
}
continue;
}
match c {
'"' | '\'' => {
quote = Some(c);
word.push(c);
}
'(' => {
depth += 1;
word.push(c);
}
')' => {
depth = depth.saturating_sub(1);
word.push(c);
}
',' if depth == 0 => {
flush(&mut word, &mut tokens);
tokens.push(Token::Comma);
}
' ' | '\t' | '\n' | '\r' | '\u{0C}' => {
if depth == 0 {
flush(&mut word, &mut tokens);
} else {
word.push(c);
}
}
_ => word.push(c),
}
}
flush(&mut word, &mut tokens);
tokens
}
fn normalize_css_word(word: &str, traits: CssPropertyTraits) -> String {
let Some(first) = word.chars().next() else {
return word.to_owned();
};
if first == '\'' {
return requote_css_string(word);
}
if first == '"' {
return word.to_owned();
}
if traits.has(CssPropertyTraits::COLOR)
&& first == '#'
&& let Some(rgba) = parse_hex_color(&word[1..])
{
return serialize_color(rgba, true);
}
if let Some(open) = word.find('(')
&& word.ends_with(')')
{
let function = word[..open].to_lowercase();
let arguments = &word[open + 1..word.len() - 1];
if traits.has(CssPropertyTraits::COLOR)
&& let Some(rgba) = parse_color_function(&function, arguments)
{
return serialize_color(rgba, false);
}
if function == "calc"
&& let Some(result) = evaluate_calc(arguments)
{
return format!("calc({result})");
}
return word.to_owned();
}
if let Some((number, unit)) = parse_css_number(word) {
if unit.is_empty() && number == 0.0 && traits.has(CssPropertyTraits::ZERO_LENGTH) {
return "0px".to_owned();
}
return format_css_number(number) + &unit.to_lowercase();
}
if traits.has(CssPropertyTraits::PRESERVE_CASE) {
word.to_owned()
} else {
word.to_lowercase()
}
}
fn requote_css_string(word: &str) -> String {
let mut body = &word[1..];
if body.ends_with('\'') {
body = &body[..body.len() - 1];
}
let mut out = String::from("\"");
let mut escaped = false;
for c in body.chars() {
if escaped {
if c != '\'' {
out.push('\\');
}
out.push(c);
escaped = false;
} else if c == '\\' {
escaped = true;
} else if c == '"' {
out.push_str("\\\"");
} else {
out.push(c);
}
}
out.push('"');
out
}
pub(crate) fn parse_css_number(word: &str) -> Option<(f64, &str)> {
let bytes = word.as_bytes();
let digit = |i: usize| bytes.get(i).is_some_and(u8::is_ascii_digit);
let mut i = 0;
if matches!(bytes.first(), Some(b'+' | b'-')) {
i += 1;
}
let mut digits = 0;
while digit(i) {
i += 1;
digits += 1;
}
if bytes.get(i) == Some(&b'.') && digit(i + 1) {
i += 1;
while digit(i) {
i += 1;
digits += 1;
}
}
if digits == 0 {
return None;
}
if matches!(bytes.get(i), Some(b'e' | b'E')) {
let mut j = i + 1;
if matches!(bytes.get(j), Some(b'+' | b'-')) {
j += 1;
}
if digit(j) {
while digit(j) {
j += 1;
}
i = j;
}
}
let unit = &word[i..];
if !unit.bytes().all(|b| b == b'%' || b.is_ascii_alphabetic()) {
return None;
}
let number: f64 = word[..i].parse().ok()?;
Some((number, unit))
}
fn format_css_number(number: f64) -> String {
if number == 0.0 {
"0".to_owned()
} else {
number_to_string(number)
}
}
pub(crate) fn evaluate_calc(arguments: &str) -> Option<String> {
let parts: Vec<&str> = arguments
.split([' ', '\t', '\n'])
.filter(|p| !p.is_empty())
.collect();
let [a, op @ ("*" | "+" | "-"), b] = parts.as_slice() else {
return None;
};
let (a, unit_a) = parse_css_number(a)?;
let (b, unit_b) = parse_css_number(b)?;
let (number, unit) = if *op == "*" {
if !(unit_a.is_empty() || unit_b.is_empty()) {
return None;
}
(a * b, format!("{unit_a}{unit_b}"))
} else {
if !unit_a.eq_ignore_ascii_case(unit_b) {
return None;
}
(if *op == "+" { a + b } else { a - b }, unit_a.to_owned())
};
Some(format_css_number(number) + &unit.to_lowercase())
}
#[derive(Clone, Copy)]
struct Rgba {
r: f64,
g: f64,
b: f64,
a: f64,
}
fn parse_hex_color(hex: &str) -> Option<Rgba> {
let digits: Vec<u32> = hex.chars().map(|c| c.to_digit(16)).collect::<Option<_>>()?;
let channels: Vec<u32> = match digits.len() {
3 | 4 => digits.iter().map(|d| d * 17).collect(),
6 | 8 => digits.chunks(2).map(|p| p[0] * 16 + p[1]).collect(),
_ => return None,
};
Some(Rgba {
r: f64::from(channels[0]),
g: f64::from(channels[1]),
b: f64::from(channels[2]),
a: if channels.len() == 4 {
f64::from(channels[3]) / 255.0
} else {
1.0
},
})
}
fn round(x: f64) -> f64 {
x.round()
}
fn parse_color_function(function: &str, arguments: &str) -> Option<Rgba> {
if !matches!(function, "rgb" | "rgba" | "hsl" | "hsla") {
return None;
}
let mut parts: Vec<&str> = arguments
.split([',', ' ', '/', '\t'])
.filter(|p| !p.is_empty())
.collect();
if !(parts.len() == 3 || parts.len() == 4) {
return None;
}
let mut alpha = 1.0;
if parts.len() == 4 {
let last = parts.pop().expect("four parts");
let (value, unit) = parse_css_number(last)?;
if !(unit.is_empty() || unit == "%") {
return None;
}
alpha = if unit == "%" { value / 100.0 } else { value };
}
let values: Vec<(f64, &str)> = parts.iter().filter_map(|p| parse_css_number(p)).collect();
if values.len() != 3 {
return None;
}
let clamp_alpha = alpha.clamp(0.0, 1.0);
if function.starts_with("rgb") {
if !values.iter().all(|(_, unit)| unit.is_empty()) {
return None;
}
let channel = |v: f64| round(v).clamp(0.0, 255.0);
return Some(Rgba {
r: channel(values[0].0),
g: channel(values[1].0),
b: channel(values[2].0),
a: clamp_alpha,
});
}
let h = ((values[0].0 % 360.0) + 360.0) % 360.0 / 360.0;
let s = (values[1].0 / 100.0).clamp(0.0, 1.0);
let l = (values[2].0 / 100.0).clamp(0.0, 1.0);
let q = if l < 0.5 {
l * (1.0 + s)
} else {
l + s - l * s
};
let p = 2.0 * l - q;
let hue = |t: f64| {
let mut t = t;
if t < 0.0 {
t += 1.0;
}
if t > 1.0 {
t -= 1.0;
}
if t < 1.0 / 6.0 {
p + (q - p) * 6.0 * t
} else if t < 1.0 / 2.0 {
q
} else if t < 2.0 / 3.0 {
p + (q - p) * (2.0 / 3.0 - t) * 6.0
} else {
p
}
};
Some(Rgba {
r: round(hue(h + 1.0 / 3.0) * 255.0),
g: round(hue(h) * 255.0),
b: round(hue(h - 1.0 / 3.0) * 255.0),
a: clamp_alpha,
})
}
fn serialize_color(color: Rgba, hex_alpha: bool) -> String {
let rgb = format!("{}, {}, {}", color.r as i64, color.g as i64, color.b as i64);
if color.a >= 1.0 {
return format!("rgb({rgb})");
}
let mut alpha = round(color.a * 1000.0) / 1000.0;
if hex_alpha {
let byte = round(color.a * 255.0);
let two_decimals = round(color.a * 100.0) / 100.0;
if round(two_decimals * 255.0) == byte {
alpha = two_decimals;
}
}
format!("rgba({rgb}, {})", format_css_number(alpha))
}