use super::*;
use crate::css::component_values::{
css_leading_ident, css_single_function, css_single_ident, split_css_top_level_once,
try_split_css_component_values, try_split_css_top_level_delimiter,
};
pub(super) fn apply_background_shorthand(
style: &mut ComputedStyle,
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) {
let value = value.trim();
let Some(layers) =
parse_background_shorthand_layers(value, style.font_size, base_url, root_url)
else {
return;
};
let Some(tokens) = background_tokens(value) else {
return;
};
style.background.background_color = if tokens
.iter()
.any(|token| css_identifier_is(token, "currentcolor"))
{
BackgroundColor::CurrentColor
} else {
parse_color_from_currentcolor_in_scheme(value, style.color, style.used_color_scheme)
.or_else(|| parse_color(value))
.or_else(|| {
tokens.iter().find_map(|token| {
parse_color_from_currentcolor_in_scheme(
token,
style.color,
style.used_color_scheme,
)
.or_else(|| parse_color(token))
})
})
.map(BackgroundColor::Color)
.unwrap_or(BackgroundColor::TRANSPARENT)
};
style.background.background_layers = layers;
style.background.background_image_layer_count = style.background.background_layers.len().max(1);
if style.background.background_layers.is_empty() {
sync_background_layers_from_single_fields(style);
} else {
sync_background_single_fields_from_layers(style);
}
}
pub(super) fn parse_background_box(value: &str) -> Option<BackgroundBox> {
match css_single_ident(trim_css_value(value))?
.to_ascii_lowercase()
.as_str()
{
"border-box" => Some(BackgroundBox::Border),
"border-area" => Some(BackgroundBox::BorderArea),
"padding-box" => Some(BackgroundBox::Padding),
"content-box" => Some(BackgroundBox::Content),
_ => None,
}
}
pub(super) fn parse_background_repeat(value: &str) -> Option<BackgroundRepeat> {
let tokens = background_tokens(value)?;
if tokens.len() == 1 && css_identifier_is(tokens[0], "repeat-x") {
return Some(BackgroundRepeat::RepeatX);
}
if tokens.len() == 1 && css_identifier_is(tokens[0], "repeat-y") {
return Some(BackgroundRepeat::RepeatY);
}
let repeat_tokens = tokens
.iter()
.filter_map(|token| {
css_single_ident(token)
.and_then(|token| parse_background_repeat_axis(&token.to_ascii_lowercase()))
})
.collect::<Vec<_>>();
match repeat_tokens.as_slice() {
[] => None,
[axis] => Some(BackgroundRepeat::new(*axis, *axis)),
[x, y] => Some(BackgroundRepeat::new(*x, *y)),
_ => None,
}
}
fn parse_background_repeat_longhand(value: &str) -> Option<BackgroundRepeat> {
let tokens = background_tokens(value)?;
tokens
.iter()
.all(|token| {
css_single_ident(token).is_some_and(|token| {
matches!(
token.to_ascii_lowercase().as_str(),
"repeat" | "space" | "round" | "no-repeat" | "repeat-x" | "repeat-y"
)
})
})
.then(|| parse_background_repeat(value))?
}
fn parse_background_repeat_axis(token: &str) -> Option<BackgroundRepeatAxis> {
match token {
"repeat" => Some(BackgroundRepeatAxis::Repeat),
"space" => Some(BackgroundRepeatAxis::Space),
"round" => Some(BackgroundRepeatAxis::Round),
"no-repeat" => Some(BackgroundRepeatAxis::NoRepeat),
_ => None,
}
}
pub(super) fn apply_background_image_list(
style: &mut ComputedStyle,
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) {
let Some(images) = parse_background_image_layers(value, base_url, root_url) else {
return;
};
if images.is_empty() {
style.background.background_image = ComputedImage::None;
style.background.background_layers.clear();
style.background.background_image_layer_count = 1;
return;
}
style.background.background_image_layer_count = images.len();
ensure_background_layer_count(style, images.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
layer.image = repeated_layer_value(&images, index);
}
sync_background_single_fields_from_layers(style);
}
pub(super) fn apply_background_size_list(style: &mut ComputedStyle, value: &str) {
let Some(values) = background_layers(value).and_then(|layers| {
layers
.into_iter()
.map(|part| parse_background_size(part, style.font_size))
.collect::<Option<Vec<_>>>()
}) else {
return;
};
ensure_background_layer_count(style, values.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
layer.size = repeated_layer_value(&values, index);
}
sync_background_single_fields_from_layers(style);
}
pub(super) fn apply_background_position_list(style: &mut ComputedStyle, value: &str) {
let Some(values) = background_layers(value).and_then(|layers| {
layers
.into_iter()
.map(|part| parse_background_position(part, style.font_size))
.collect::<Option<Vec<_>>>()
}) else {
return;
};
ensure_background_layer_count(style, values.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
layer.position = repeated_layer_value(&values, index);
}
sync_background_single_fields_from_layers(style);
}
pub(super) fn apply_background_position_axis_list(
style: &mut ComputedStyle,
value: &str,
horizontal: bool,
) {
let Some(values) = background_layers(value).and_then(|layers| {
layers
.into_iter()
.map(|part| parse_background_position_axis(part, style.font_size, horizontal))
.collect::<Option<Vec<_>>>()
}) else {
return;
};
ensure_background_layer_count(style, values.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
if horizontal {
layer.position.x = repeated_layer_value(&values, index);
} else {
layer.position.y = repeated_layer_value(&values, index);
}
}
sync_background_single_fields_from_layers(style);
}
pub(super) fn apply_background_repeat_list(style: &mut ComputedStyle, value: &str) {
let Some(values) = background_layers(value).and_then(|layers| {
layers
.into_iter()
.map(parse_background_repeat_longhand)
.collect::<Option<Vec<_>>>()
}) else {
return;
};
ensure_background_layer_count(style, values.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
layer.repeat = repeated_layer_value(&values, index);
}
sync_background_single_fields_from_layers(style);
}
pub(super) fn apply_background_attachment_list(style: &mut ComputedStyle, value: &str) {
let Some(values) = background_layers(value).and_then(|layers| {
layers
.into_iter()
.map(|value| {
match css_single_ident(trim_css_value(value))?
.to_ascii_lowercase()
.as_str()
{
"scroll" => Some(BackgroundAttachment::Scroll),
"fixed" => Some(BackgroundAttachment::Fixed),
"local" => Some(BackgroundAttachment::Local),
_ => None,
}
})
.collect::<Option<Vec<_>>>()
}) else {
return;
};
ensure_background_layer_count(style, values.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
layer.attachment = repeated_layer_value(&values, index);
}
sync_background_single_fields_from_layers(style);
}
pub(super) fn apply_background_origin_list(style: &mut ComputedStyle, value: &str) {
let Some(values) = background_layers(value).and_then(|layers| {
layers
.into_iter()
.map(|value| {
parse_background_box(value).filter(|box_| *box_ != BackgroundBox::BorderArea)
})
.collect::<Option<Vec<_>>>()
}) else {
return;
};
ensure_background_layer_count(style, values.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
layer.origin = repeated_layer_value(&values, index);
}
sync_background_single_fields_from_layers(style);
}
pub(super) fn apply_background_clip_list(style: &mut ComputedStyle, value: &str) {
let Some(values) = background_layers(value).and_then(|layers| {
layers
.into_iter()
.map(parse_background_box)
.collect::<Option<Vec<_>>>()
}) else {
return;
};
ensure_background_layer_count(style, values.len());
for (index, layer) in style.background.background_layers.iter_mut().enumerate() {
layer.clip = repeated_layer_value(&values, index);
}
sync_background_single_fields_from_layers(style);
}
pub(crate) fn parse_background_size(value: &str, font_size: f32) -> Option<BackgroundSize> {
let value = trim_css_value(value);
if css_identifier_is(value, "auto") {
return Some(BackgroundSize::Auto);
}
if css_identifier_is(value, "cover") {
return Some(BackgroundSize::Cover);
}
if css_identifier_is(value, "contain") {
return Some(BackgroundSize::Contain);
}
let parts = background_components(value)?;
let (width, height) = match parts.as_slice() {
[width] => (
parse_background_size_axis(width, font_size)?,
BackgroundSizeAxis::Auto,
),
[width, height] => (
parse_background_size_axis(width, font_size)?,
parse_background_size_axis(height, font_size)?,
),
_ => return None,
};
Some(BackgroundSize::Explicit { width, height })
}
fn parse_background_size_axis(value: &str, font_size: f32) -> Option<BackgroundSizeAxis> {
let value = trim_css_value(value);
if css_identifier_is(value, "auto") {
Some(BackgroundSizeAxis::Auto)
} else {
let value = parse_computed_length_percentage(value, font_size)?;
if value
.length_if_no_percent()
.is_some_and(|length| length < 0.0)
{
return None;
}
Some(BackgroundSizeAxis::LengthPercentage(value))
}
}
pub(crate) fn parse_background_position(value: &str, font_size: f32) -> Option<BackgroundPosition> {
let tokens = background_components(trim_css_value(value))?;
if tokens.is_empty() {
return None;
}
if tokens.len() <= 2
&& tokens
.iter()
.all(|token| parse_computed_length_percentage(token, font_size).is_some())
{
let x = parse_computed_length_percentage(tokens[0], font_size)?;
let y = if let Some(value) = tokens.get(1) {
BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Start,
offset: parse_computed_length_percentage(value, font_size)?,
}
} else {
BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Center,
offset: ComputedLengthPercentage::ZERO,
}
};
return Some(BackgroundPosition {
x: BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Start,
offset: x,
},
y,
});
}
if !tokens.iter().all(|token| {
matches!(
css_single_ident(token).as_deref(),
Some("left" | "right" | "top" | "bottom" | "center")
) || parse_computed_length_percentage(token, font_size).is_some()
}) {
return None;
}
let mut position = BackgroundPosition::INITIAL;
if tokens
.iter()
.any(|token| css_identifier_is(token, "center"))
{
position.x.origin = BackgroundPositionOrigin::Center;
position.y.origin = BackgroundPositionOrigin::Center;
}
if tokens.iter().any(|token| css_identifier_is(token, "right")) {
position.x.origin = BackgroundPositionOrigin::End;
} else if tokens.iter().any(|token| css_identifier_is(token, "left")) {
position.x.origin = BackgroundPositionOrigin::Start;
}
if tokens
.iter()
.any(|token| css_identifier_is(token, "bottom"))
{
position.y.origin = BackgroundPositionOrigin::End;
} else if tokens.iter().any(|token| css_identifier_is(token, "top")) {
position.y.origin = BackgroundPositionOrigin::Start;
}
for pair in tokens.windows(2) {
if css_identifier_is(pair[0], "left") || css_identifier_is(pair[0], "right") {
if let Some(offset) = parse_computed_length_percentage(pair[1], font_size) {
position.x.offset = offset;
}
} else if (css_identifier_is(pair[0], "top") || css_identifier_is(pair[0], "bottom"))
&& let Some(offset) = parse_computed_length_percentage(pair[1], font_size)
{
position.y.offset = offset;
}
}
Some(position)
}
fn parse_background_position_axis(
value: &str,
font_size: f32,
horizontal: bool,
) -> Option<BackgroundPositionAxis> {
let tokens = background_components(trim_css_value(value))?;
let (start, end) = if horizontal {
("left", "right")
} else {
("top", "bottom")
};
match tokens.as_slice() {
[value] => {
if let Some(offset) = parse_computed_length_percentage(value, font_size) {
return Some(BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Start,
offset,
});
}
let origin = match css_single_ident(value)?.to_ascii_lowercase().as_str() {
"center" => BackgroundPositionOrigin::Center,
value if value == start => BackgroundPositionOrigin::Start,
value if value == end => BackgroundPositionOrigin::End,
_ => return None,
};
Some(BackgroundPositionAxis {
origin,
offset: ComputedLengthPercentage::ZERO,
})
}
[side, offset] => {
let offset = parse_computed_length_percentage(offset, font_size)?;
let origin = match css_single_ident(side)?.to_ascii_lowercase().as_str() {
value if value == start => BackgroundPositionOrigin::Start,
"center" => BackgroundPositionOrigin::Center,
value if value == end => BackgroundPositionOrigin::End,
_ => return None,
};
Some(BackgroundPositionAxis { origin, offset })
}
_ => None,
}
}
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum ParsedImage {
NotAnImage,
SyntaxError,
Image(ComputedImage),
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ImageParseContext {
General,
ImageSetCandidate,
}
pub(crate) fn parse_css_image(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> ParsedImage {
parse_css_image_in_context(value, base_url, root_url, ImageParseContext::General)
}
fn parse_css_image_in_context(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
context: ImageParseContext,
) -> ParsedImage {
if context == ImageParseContext::General {
match parse_image_set(value, base_url, root_url) {
ParsedImage::NotAnImage => {}
image => return image,
}
}
parse_css_image_without_image_set_in_context(value, base_url, root_url, context)
}
fn parse_css_image_without_image_set(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> ParsedImage {
parse_css_image_without_image_set_in_context(
value,
base_url,
root_url,
ImageParseContext::ImageSetCandidate,
)
}
fn parse_css_image_without_image_set_in_context(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
context: ImageParseContext,
) -> ParsedImage {
if let Some(image) = parse_light_dark_image(value, base_url, root_url, context) {
return image;
}
if let Some(gradient) = parse_conic_gradient(value) {
return ParsedImage::Image(ComputedImage::image(BackgroundImage::ConicGradient(
gradient,
)));
}
if let Some(image) = parse_image_function(value, base_url, root_url) {
return image;
}
if let Some(gradient) = parse_linear_gradient(value) {
return ParsedImage::Image(ComputedImage::image(BackgroundImage::LinearGradient(
gradient,
)));
}
if let Some(gradient) = parse_radial_gradient(value) {
return ParsedImage::Image(ComputedImage::image(BackgroundImage::RadialGradient(
gradient,
)));
}
let Some(url) = parse_first_css_url_with_modifiers(value) else {
return ParsedImage::NotAnImage;
};
ParsedImage::Image(ComputedImage::image(BackgroundImage::Url(ImageUrl {
href: url.src,
base_url: base_url.cloned(),
root_url: root_url.cloned(),
request_modifiers: url.modifiers,
})))
}
fn parse_light_dark_image(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
context: ImageParseContext,
) -> Option<ParsedImage> {
let (arguments, tail) = css_leading_function_matching(trim_css_value(value), "light-dark")?;
if !tail.trim().is_empty() {
return Some(ParsedImage::SyntaxError);
}
let branches = crate::css::component_values::split_css_top_level_delimiter(arguments, ',');
let [light, dark] = branches.as_slice() else {
return Some(ParsedImage::SyntaxError);
};
let parse_branch = |branch: &&str| {
let branch = trim_css_value(branch);
if branch.eq_ignore_ascii_case("none") {
return ParsedImage::Image(ComputedImage::image(BackgroundImage::CssColor(
ColorImageColor::CssColor(CssColor::TRANSPARENT),
)));
}
parse_css_image_in_context(branch, base_url, root_url, context)
};
match (parse_branch(light), parse_branch(dark)) {
(
ParsedImage::Image(ComputedImage::Image(light)),
ParsedImage::Image(ComputedImage::Image(dark)),
) => Some(ParsedImage::Image(ComputedImage::image(
BackgroundImage::LightDark(LightDarkImage { light, dark }),
))),
(ParsedImage::NotAnImage, ParsedImage::NotAnImage) => Some(ParsedImage::NotAnImage),
_ => Some(ParsedImage::SyntaxError),
}
}
pub(crate) fn parse_background_image(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> Option<BackgroundImage> {
match parse_css_image(value, base_url, root_url) {
ParsedImage::Image(ComputedImage::Image(image)) => Some(*image),
ParsedImage::NotAnImage | ParsedImage::SyntaxError | ParsedImage::Image(_) => None,
}
}
fn parse_image_function(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> Option<ParsedImage> {
let (arguments, tail) = css_leading_function_matching(trim_css_value(value), "image")?;
if !tail.trim().is_empty() {
return Some(ParsedImage::SyntaxError);
}
let arguments = crate::css::component_values::split_css_top_level_delimiter(arguments, ',');
let ([before] | [before, _]) = arguments.as_slice() else {
return Some(ParsedImage::SyntaxError);
};
let has_fallback_slot = arguments.len() == 2;
let mut before = trim_css_value(before);
let mut directionality = None;
if let Some((ident, tail)) = css_leading_ident(before)
&& let Some(direction) = match ident.to_ascii_lowercase().as_str() {
"ltr" => Some(ImageDirectionality::Ltr),
"rtl" => Some(ImageDirectionality::Rtl),
_ => None,
}
{
directionality = Some(direction);
before = trim_css_value(tail);
}
if let Some((_, tail)) = css_leading_function_matching(before, "url")
&& !tail.trim().is_empty()
{
return Some(ParsedImage::SyntaxError);
}
if before.len() >= 4
&& before[..4].eq_ignore_ascii_case("url(")
&& before
.rfind(')')
.is_none_or(|close| !before[close + 1..].trim().is_empty())
{
return Some(ParsedImage::SyntaxError);
}
let source = parse_image_function_source(before, base_url, root_url);
if source.is_none()
&& (css_leading_function_matching(before, "url").is_some()
|| parse_css_string_token(before).is_some())
{
return Some(ParsedImage::SyntaxError);
}
let fallback_color = if has_fallback_slot {
let fallback = trim_css_value(arguments[1]);
if fallback.is_empty() {
return Some(ParsedImage::SyntaxError);
} else if parse_image_function_source(fallback, base_url, root_url).is_some() {
return Some(ParsedImage::SyntaxError);
} else if fallback.eq_ignore_ascii_case("currentcolor") {
Some(ColorImageColor::CurrentColor)
} else {
Some(parse_color(fallback).map(ColorImageColor::CssColor)?)
}
} else if before.is_empty() {
None
} else if source.is_none() {
if before.eq_ignore_ascii_case("currentcolor") {
Some(ColorImageColor::CurrentColor)
} else {
Some(parse_color(before).map(ColorImageColor::CssColor)?)
}
} else {
None
};
if source.is_none() && !before.is_empty() && has_fallback_slot
|| directionality.is_some() && source.is_none()
|| source.is_none() && fallback_color.is_none()
{
return Some(ParsedImage::SyntaxError);
}
Some(ParsedImage::Image(ComputedImage::image(
BackgroundImage::ImageFunction(ImageFunction {
source,
fallback_color,
directionality,
}),
)))
}
fn parse_image_function_source(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> Option<ImageUrl> {
if value.is_empty() {
return None;
}
if let Some((url, tail)) = parse_css_url_token_with_modifiers(value)
&& tail.trim().is_empty()
{
return Some(ImageUrl {
href: url.src,
base_url: base_url.cloned(),
root_url: root_url.cloned(),
request_modifiers: url.modifiers,
});
}
let (href, tail) = parse_css_string_token(value)?;
tail.trim().is_empty().then_some(ImageUrl {
href,
base_url: base_url.cloned(),
root_url: root_url.cloned(),
request_modifiers: RequestUrlModifiers::default(),
})
}
fn parse_conic_gradient(value: &str) -> Option<ConicGradient> {
let value = trim_css_value(value);
let (repeating, parts) =
gradient_arguments(value, "conic-gradient", "repeating-conic-gradient")?;
let (start_angle, position, interpolation, first_stop) =
parse_conic_prelude(parts.first()?.trim())?;
let stop_parts = if first_stop {
&parts[1..]
} else {
parts.as_slice()
};
let mut stops = Vec::new();
for part in stop_parts {
stops.extend(parse_conic_gradient_stop(part.trim())?);
}
(!stops.is_empty()).then_some(())?;
Some(ConicGradient {
start_angle,
position,
interpolation,
repeating,
stops,
})
}
fn parse_conic_prelude(
value: &str,
) -> Option<(f32, BackgroundPosition, GradientInterpolationMethod, bool)> {
let (interpolation, value) = split_gradient_interpolation_method(value)?;
let tokens = background_components(&value)?;
let Some(first) = tokens.first() else {
return interpolation.map(|method| (0.0, radial_gradient_center_position(), method, true));
};
if interpolation.is_none() && parse_gradient_color(first).is_some() {
return Some((
0.0,
radial_gradient_center_position(),
GradientInterpolationMethod::CSS_IMAGES_3,
false,
));
}
let mut angle = 0.0;
let mut position = radial_gradient_center_position();
if let Some(from) = tokens
.iter()
.position(|token| css_identifier_is(token, "from"))
&& let Some(value) = tokens
.get(from + 1)
.and_then(|value| parse_css_angle_degrees(value))
{
angle = value;
}
if let Some(at) = tokens
.iter()
.position(|token| css_identifier_is(token, "at"))
{
let value = tokens[at + 1..].join(" ");
if let Some(parsed) = parse_radial_gradient_position(&value) {
position = parsed;
}
}
Some((
angle,
position,
interpolation.unwrap_or(GradientInterpolationMethod::CSS_IMAGES_3),
true,
))
}
fn parse_conic_gradient_stop(value: &str) -> Option<Vec<ConicGradientStop>> {
let tokens = background_components(value)?;
for split in (1..=tokens.len()).rev() {
let Some(color) = parse_gradient_color(&tokens[..split].join(" ")) else {
continue;
};
let positions = tokens[split..]
.iter()
.map(|value| parse_conic_angle_percentage(value))
.collect::<Option<Vec<_>>>()?;
if positions.len() <= 2 {
return Some(match positions.as_slice() {
[] => vec![ConicGradientStop {
color,
position: None,
}],
[position] => vec![ConicGradientStop {
color,
position: Some(*position),
}],
[first, second] => vec![
ConicGradientStop {
color,
position: Some(*first),
},
ConicGradientStop {
color,
position: Some(*second),
},
],
_ => unreachable!(),
});
}
}
None
}
fn parse_conic_angle_percentage(value: &str) -> Option<f32> {
parse_css_angle_degrees(value).or_else(|| {
value
.strip_suffix('%')?
.trim()
.parse::<f32>()
.ok()
.map(|value| value * 3.6)
})
}
fn parse_image_set(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> ParsedImage {
let value = trim_css_value(value);
let Some((name, body, tail)) = crate::css::component_values::css_leading_function(value) else {
return ParsedImage::NotAnImage;
};
if !name.eq_ignore_ascii_case("image-set") && !name.eq_ignore_ascii_case("-webkit-image-set") {
return ParsedImage::NotAnImage;
}
if !tail.trim().is_empty() {
return ParsedImage::SyntaxError;
}
let mut options = Vec::new();
for option in crate::css::component_values::split_css_top_level_delimiter(body, ',') {
match parse_image_set_option(option, base_url, root_url) {
Ok(option) => options.push(option),
Err(()) => return ParsedImage::SyntaxError,
}
}
if options.is_empty() {
return ParsedImage::SyntaxError;
}
ParsedImage::Image(ComputedImage::image(BackgroundImage::ImageSet(ImageSet {
options,
})))
}
fn parse_image_set_option(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> Result<ImageSetOption, ()> {
let value = trim_css_value(value);
let (image, tail) = parse_image_set_option_image(value, base_url, root_url).ok_or(())?;
let (resolution_descriptor, mime_type) = parse_image_set_option_descriptors(tail).ok_or(())?;
let resolution = parse_image_set_resolution(resolution_descriptor).ok_or(())?;
if !resolution.is_finite() {
return Err(());
}
if resolution < 0.0 && css_leading_function_matching(resolution_descriptor, "calc").is_none() {
return Err(());
}
Ok(ImageSetOption {
image: Box::new(image),
resolution_dppx: resolution,
mime_type,
})
}
fn parse_image_set_option_descriptors(value: &str) -> Option<(&str, Option<String>)> {
let value = value.trim();
if value.is_empty() {
return Some(("", None));
}
let tokens = split_css_component_values(value);
let mut resolution = None;
let mut mime_type = None;
for token in tokens {
if let Some((name, body, tail)) = crate::css::component_values::css_leading_function(token)
&& name.eq_ignore_ascii_case("type")
{
if mime_type.is_some() {
return None;
}
if !tail.trim().is_empty() {
return None;
}
let (mime, tail) = parse_css_string_token(body.trim())?;
if !tail.trim().is_empty() {
return None;
}
mime_type = Some(mime);
} else if resolution.replace(token).is_some() {
return None;
}
}
Some((resolution.unwrap_or(""), mime_type))
}
fn parse_image_set_option_image<'a>(
value: &'a str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> Option<(BackgroundImage, &'a str)> {
if let Some((url, tail)) = parse_css_url_token_with_modifiers(value) {
return Some((
BackgroundImage::Url(ImageUrl {
href: url.src,
base_url: base_url.cloned(),
root_url: root_url.cloned(),
request_modifiers: url.modifiers,
}),
tail,
));
}
if let Some((url, tail)) = parse_css_string_token(value) {
return Some((
BackgroundImage::Url(ImageUrl {
href: url,
base_url: base_url.cloned(),
root_url: root_url.cloned(),
request_modifiers: RequestUrlModifiers::default(),
}),
tail,
));
}
let (name, arguments, tail) = crate::css::component_values::css_leading_function(value)?;
if [
"image",
"linear-gradient",
"repeating-linear-gradient",
"radial-gradient",
"repeating-radial-gradient",
"conic-gradient",
"repeating-conic-gradient",
"light-dark",
]
.iter()
.any(|known| name.eq_ignore_ascii_case(known))
{
let ParsedImage::Image(ComputedImage::Image(image)) =
parse_css_image_without_image_set(&format!("{name}({arguments})"), base_url, root_url)
else {
return None;
};
return Some((*image, tail));
}
None
}
fn parse_image_set_resolution(value: &str) -> Option<f32> {
if value.is_empty() {
return Some(1.0);
}
let calculated =
crate::css::component_values::css_leading_function(value).is_some_and(|(name, _, tail)| {
tail.trim().is_empty()
&& matches!(
name.to_ascii_lowercase().as_str(),
"calc" | "min" | "max" | "clamp" | "sign"
)
});
let resolution = crate::css::values::parse_math_resolution(value)?;
if !calculated && resolution < 0.0 {
return None;
}
Some(if calculated {
resolution.max(0.0)
} else {
resolution
})
}
pub(super) fn sync_background_layers_from_single_fields(style: &mut ComputedStyle) {
let layer = layer_from_single_fields(style);
style.background.background_layers = vec![layer];
style.background.background_image_layer_count = 1;
}
pub(super) fn sync_background_single_fields_from_layers(style: &mut ComputedStyle) {
let Some(layer) = style.background.background_layers.first().cloned() else {
style.background.background_image = ComputedImage::None;
style.background.background_size = BackgroundSize::AUTO;
style.background.background_position = BackgroundPosition::INITIAL;
style.background.background_repeat = BackgroundRepeat::Repeat;
style.background.background_origin = BackgroundBox::Padding;
style.background.background_clip = BackgroundBox::Border;
return;
};
style.background.background_image = layer.image;
style.background.background_size = layer.size;
style.background.background_position = layer.position;
style.background.background_repeat = layer.repeat;
style.background.background_attachment = layer.attachment;
style.background.background_origin = layer.origin;
style.background.background_clip = layer.clip;
}
pub(super) fn normalize_background_layers(style: &mut ComputedStyle) {
if style.background.background_layers.is_empty() {
let layer = layer_from_single_fields(style);
style.background.background_layers.push(layer);
}
let layer_count = style.background.background_image_layer_count.max(1);
style.background.background_layers.truncate(layer_count);
sync_background_single_fields_from_layers(style);
}
fn layer_from_single_fields(style: &ComputedStyle) -> BackgroundLayer {
BackgroundLayer {
image: style.background.background_image.clone(),
position: style.background.background_position.clone(),
size: style.background.background_size.clone(),
repeat: style.background.background_repeat,
attachment: style.background.background_attachment,
origin: style.background.background_origin,
clip: style.background.background_clip,
}
}
fn ensure_background_layer_count(style: &mut ComputedStyle, count: usize) {
if count == 0 {
return;
}
if style.background.background_layers.is_empty() {
let layer = layer_from_single_fields(style);
style.background.background_layers.push(layer);
}
while style.background.background_layers.len() < count {
let layer = style
.background
.background_layers
.last()
.cloned()
.unwrap_or_else(BackgroundLayer::initial);
style.background.background_layers.push(layer);
}
}
fn repeated_layer_value<T: Clone>(values: &[T], index: usize) -> T {
values[index % values.len()].clone()
}
fn parse_background_image_layers(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> Option<Vec<ComputedImage>> {
let mut images = Vec::new();
for part in background_layers(value)? {
let image = if css_identifier_is(trim_css_value(part), "none") {
ComputedImage::None
} else {
match parse_css_image(part, base_url, root_url) {
ParsedImage::Image(image) => image,
ParsedImage::NotAnImage | ParsedImage::SyntaxError => return None,
}
};
images.push(image);
}
Some(images)
}
fn parse_background_shorthand_layers(
value: &str,
font_size: f32,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> Option<Vec<BackgroundLayer>> {
background_layers(value)?
.into_iter()
.map(|part| {
background_shorthand_layer_is_valid(part, font_size)?;
let mut layer = BackgroundLayer::initial();
layer.image = match parse_background_shorthand_image(part, base_url, root_url) {
ParsedImage::Image(image) => image,
ParsedImage::NotAnImage => ComputedImage::None,
ParsedImage::SyntaxError => return None,
};
layer.repeat = parse_background_repeat(part).unwrap_or(BackgroundRepeat::Repeat);
layer.attachment = background_tokens(part)?
.into_iter()
.find_map(
|token| match css_single_ident(token)?.to_ascii_lowercase().as_str() {
"scroll" => Some(BackgroundAttachment::Scroll),
"fixed" => Some(BackgroundAttachment::Fixed),
"local" => Some(BackgroundAttachment::Local),
_ => None,
},
)
.unwrap_or(BackgroundAttachment::Scroll);
let (position, size) = match split_background_position_size(part)? {
Some((position, size)) => (position, Some(size)),
None => (strip_background_noise(part)?, None),
};
if !position.trim().is_empty()
&& let Some(position) = parse_background_position(position.trim(), font_size)
{
layer.position = position;
}
if let Some(size) = size
&& !size.trim().is_empty()
&& let Some(size) = parse_background_size(size.trim(), font_size)
{
layer.size = size;
}
let boxes = background_tokens(part)?
.into_iter()
.filter_map(parse_background_box)
.collect::<Vec<_>>();
match boxes.as_slice() {
[BackgroundBox::BorderArea] => layer.clip = BackgroundBox::BorderArea,
[box_] => {
layer.origin = *box_;
layer.clip = *box_;
}
[origin, clip, ..] => {
layer.origin = *origin;
layer.clip = *clip;
}
[] => {}
}
Some(layer)
})
.collect::<Option<Vec<_>>>()
}
fn parse_background_shorthand_image(
value: &str,
base_url: Option<&url::Url>,
root_url: Option<&url::Url>,
) -> ParsedImage {
let Some(components) = background_components(value) else {
return ParsedImage::SyntaxError;
};
let mut image = None;
for component in components {
match parse_css_image(component, base_url, root_url) {
ParsedImage::Image(candidate) => {
if image.replace(candidate).is_some() {
return ParsedImage::SyntaxError;
}
}
ParsedImage::NotAnImage => {}
ParsedImage::SyntaxError => return ParsedImage::SyntaxError,
}
}
image.map_or(ParsedImage::NotAnImage, ParsedImage::Image)
}
fn background_shorthand_layer_is_valid(value: &str, font_size: f32) -> Option<()> {
let (position, size) = match split_background_position_size(value)? {
Some((position, size)) => (position, Some(size)),
None => (strip_background_noise(value)?, None),
};
if !position.trim().is_empty() && parse_background_position(&position, font_size).is_none() {
return None;
}
if let Some(size) = size
&& !size.trim().is_empty()
&& parse_background_size(&size, font_size).is_none()
{
return None;
}
Some(())
}
fn background_layers(value: &str) -> Option<Vec<&str>> {
let layers = try_split_css_top_level_delimiter(value, ',')?;
(!layers.is_empty() && layers.iter().all(|layer| !trim_css_value(layer).is_empty()))
.then_some(layers)
}
fn background_components(value: &str) -> Option<Vec<&str>> {
try_split_css_component_values(value)
}
fn css_identifier_is(value: &str, expected: &str) -> bool {
css_single_ident(value).is_some_and(|ident| ident.eq_ignore_ascii_case(expected))
}
pub(crate) fn parse_linear_gradient(value: &str) -> Option<LinearGradient> {
let (repeating, parts) =
gradient_arguments(value, "linear-gradient", "repeating-linear-gradient")?;
let mut first_stop = 0usize;
let (direction, interpolation) = match parse_linear_gradient_prelude(parts[0].trim())? {
Some(prelude) => {
first_stop = 1;
prelude
}
None => (
LinearGradientDirection::Angle(180.0),
GradientInterpolationMethod::CSS_IMAGES_3,
),
};
let mut stops = Vec::new();
let mut hints = Vec::new();
for part in &parts[first_stop..] {
parse_gradient_item(part.trim(), &mut stops, &mut hints)?;
}
if stops.is_empty() {
return None;
}
if stops.len() == 1 {
stops.push(stops[0].clone());
}
if hints.iter().any(|hint| hint.after_stop + 1 >= stops.len()) {
return None;
}
Some(LinearGradient {
direction,
interpolation,
repeating,
stops,
hints,
})
}
pub(crate) fn parse_radial_gradient(value: &str) -> Option<RadialGradient> {
let (repeating, parts) =
gradient_arguments(value, "radial-gradient", "repeating-radial-gradient")?;
let mut first_stop = 0usize;
let (shape, size, position, interpolation) = match parse_radial_gradient_prelude(parts[0])? {
Some(prelude) => {
first_stop = 1;
prelude
}
None => (
RadialGradientShape::Ellipse,
RadialGradientSize::Extent(RadialGradientExtent::FarthestCorner),
radial_gradient_center_position(),
GradientInterpolationMethod::CSS_IMAGES_3,
),
};
let mut stops = Vec::new();
let mut hints = Vec::new();
for part in &parts[first_stop..] {
parse_gradient_item(part.trim(), &mut stops, &mut hints)?;
}
if stops.is_empty() {
return None;
}
if stops.len() == 1 {
stops.push(stops[0].clone());
}
if hints.iter().any(|hint| hint.after_stop + 1 >= stops.len()) {
return None;
}
Some(RadialGradient {
shape,
size,
position,
interpolation,
repeating,
stops,
hints,
})
}
fn parse_radial_gradient_prelude(
value: &str,
) -> Option<
Option<(
RadialGradientShape,
RadialGradientSize,
BackgroundPosition,
GradientInterpolationMethod,
)>,
> {
let (interpolation, value) = split_gradient_interpolation_method(value)?;
if interpolation.is_none() && parse_color(&value).is_some() {
return Some(None);
}
let (size_text, position) = split_radial_gradient_position(&value)?;
let (shape, size) = parse_radial_gradient_shape_and_size(&size_text)?;
Some(Some((
shape,
size,
position,
interpolation.unwrap_or(GradientInterpolationMethod::CSS_IMAGES_3),
)))
}
fn split_radial_gradient_position(value: &str) -> Option<(String, BackgroundPosition)> {
let tokens = background_components(value)?;
let Some(at_index) = tokens
.iter()
.position(|token| css_identifier_is(token, "at"))
else {
return Some((value.to_string(), radial_gradient_center_position()));
};
let before = tokens[..at_index].join(" ");
let after = tokens[at_index + 1..].join(" ");
if after.trim().is_empty() {
return None;
}
let position = parse_radial_gradient_position(&after)?;
Some((before, position))
}
fn parse_radial_gradient_shape_and_size(
value: &str,
) -> Option<(RadialGradientShape, RadialGradientSize)> {
let tokens = background_components(value)?;
if tokens.is_empty() {
return Some((
RadialGradientShape::Ellipse,
RadialGradientSize::Extent(RadialGradientExtent::FarthestCorner),
));
}
let mut shape = None;
let mut extent = None;
let mut lengths = Vec::new();
for token in tokens {
let keyword = css_single_ident(token).map(|keyword| keyword.to_ascii_lowercase());
match keyword.as_deref() {
Some("circle") if shape.is_none() => shape = Some(RadialGradientShape::Circle),
Some("ellipse") if shape.is_none() => shape = Some(RadialGradientShape::Ellipse),
Some("closest-side") if extent.is_none() => {
extent = Some(RadialGradientExtent::ClosestSide);
}
Some("farthest-side") if extent.is_none() => {
extent = Some(RadialGradientExtent::FarthestSide);
}
Some("closest-corner") if extent.is_none() => {
extent = Some(RadialGradientExtent::ClosestCorner);
}
Some("farthest-corner") if extent.is_none() => {
extent = Some(RadialGradientExtent::FarthestCorner);
}
_ => lengths.push(parse_deferred_length_percentage(token)?),
}
}
if extent.is_some() && !lengths.is_empty() {
return None;
}
let shape = shape.unwrap_or(if lengths.len() == 1 {
RadialGradientShape::Circle
} else {
RadialGradientShape::Ellipse
});
let size = if let Some(extent) = extent {
RadialGradientSize::Extent(extent)
} else {
match lengths.as_slice() {
[] => RadialGradientSize::Extent(RadialGradientExtent::FarthestCorner),
[radius] if shape == RadialGradientShape::Circle => {
RadialGradientSize::CircleRadius(radius.clone())
}
[x, y] if shape == RadialGradientShape::Ellipse => RadialGradientSize::EllipseRadii {
x: x.clone(),
y: y.clone(),
},
_ => return None,
}
};
Some((shape, size))
}
fn parse_radial_gradient_position(value: &str) -> Option<BackgroundPosition> {
let tokens = background_components(value)?;
let lengths = tokens
.iter()
.map(|token| parse_deferred_length_percentage(token))
.collect::<Option<Vec<_>>>();
match lengths.as_deref() {
Some([x]) => {
return Some(BackgroundPosition {
x: BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Start,
offset: x.clone(),
},
y: BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Center,
offset: ComputedLengthPercentage::ZERO,
},
});
}
Some([x, y]) => {
return Some(BackgroundPosition {
x: BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Start,
offset: x.clone(),
},
y: BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Start,
offset: y.clone(),
},
});
}
_ => {}
}
parse_background_position(value, ROOT_FONT_SIZE_PT)
}
fn radial_gradient_center_position() -> BackgroundPosition {
BackgroundPosition {
x: BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Center,
offset: ComputedLengthPercentage::ZERO,
},
y: BackgroundPositionAxis {
origin: BackgroundPositionOrigin::Center,
offset: ComputedLengthPercentage::ZERO,
},
}
}
fn parse_linear_gradient_direction(value: &str) -> Option<LinearGradientDirection> {
let value = trim_css_value(value);
if let Some(angle) = parse_css_angle_degrees(value) {
return Some(LinearGradientDirection::Angle(angle));
}
let tokens = background_components(value)?;
let first = tokens.first()?;
if !css_identifier_is(first, "to") {
return None;
}
let rest = &tokens[1..];
if rest.is_empty() || rest.len() > 2 {
return None;
}
let mut horizontal = None;
let mut vertical = None;
for token in rest {
match css_single_ident(token)?.to_ascii_lowercase().as_str() {
"left" if horizontal.is_none() => horizontal = Some(GradientHorizontalDirection::Left),
"right" if horizontal.is_none() => {
horizontal = Some(GradientHorizontalDirection::Right);
}
"top" if vertical.is_none() => vertical = Some(GradientVerticalDirection::Top),
"bottom" if vertical.is_none() => vertical = Some(GradientVerticalDirection::Bottom),
_ => return None,
}
}
match (horizontal, vertical) {
(None, Some(GradientVerticalDirection::Top)) => Some(LinearGradientDirection::Angle(0.0)),
(Some(GradientHorizontalDirection::Right), None) => {
Some(LinearGradientDirection::Angle(90.0))
}
(None, Some(GradientVerticalDirection::Bottom)) => {
Some(LinearGradientDirection::Angle(180.0))
}
(Some(GradientHorizontalDirection::Left), None) => {
Some(LinearGradientDirection::Angle(270.0))
}
(Some(horizontal), Some(vertical)) => Some(LinearGradientDirection::Corner {
horizontal,
vertical,
}),
_ => None,
}
}
fn split_gradient_interpolation_method(
value: &str,
) -> Option<(Option<GradientInterpolationMethod>, String)> {
let tokens = background_components(value)?;
let in_positions = tokens
.iter()
.enumerate()
.filter_map(|(index, token)| css_identifier_is(token, "in").then_some(index))
.collect::<Vec<_>>();
if in_positions.is_empty() {
return Some((None, value.trim().to_string()));
}
if in_positions.len() != 1 {
return None;
}
let index = in_positions[0];
let space = css_single_ident(tokens.get(index + 1)?)?.to_ascii_lowercase();
let space = match space.as_str() {
"srgb" => GradientInterpolationSpace::Srgb,
"srgb-linear" => GradientInterpolationSpace::SrgbLinear,
"display-p3" => GradientInterpolationSpace::DisplayP3,
"display-p3-linear" => GradientInterpolationSpace::DisplayP3Linear,
"a98-rgb" => GradientInterpolationSpace::A98Rgb,
"prophoto-rgb" => GradientInterpolationSpace::ProphotoRgb,
"rec2020" => GradientInterpolationSpace::Rec2020,
"xyz-d50" => GradientInterpolationSpace::XyzD50,
"xyz" | "xyz-d65" => GradientInterpolationSpace::XyzD65,
"lab" => GradientInterpolationSpace::Lab,
"oklab" => GradientInterpolationSpace::Oklab,
"hsl" => GradientInterpolationSpace::Hsl,
"hwb" => GradientInterpolationSpace::Hwb,
"lch" => GradientInterpolationSpace::Lch,
"oklch" => GradientInterpolationSpace::Oklch,
_ => return None,
};
let mut consumed = 2;
let hue = if space.is_polar()
&& let (Some(method), Some(keyword)) = (tokens.get(index + 2), tokens.get(index + 3))
&& css_identifier_is(keyword, "hue")
{
consumed += 2;
match css_single_ident(method)?.to_ascii_lowercase().as_str() {
"shorter" => HueInterpolationMethod::Shorter,
"longer" => HueInterpolationMethod::Longer,
"increasing" => HueInterpolationMethod::Increasing,
"decreasing" => HueInterpolationMethod::Decreasing,
_ => return None,
}
} else {
HueInterpolationMethod::Shorter
};
if !space.is_polar()
&& tokens.get(index + 2).is_some_and(|token| {
matches!(
css_single_ident(token).as_deref(),
Some("shorter" | "longer" | "increasing" | "decreasing" | "hue")
)
})
{
return None;
}
let mut remaining = Vec::with_capacity(tokens.len().saturating_sub(consumed));
for (token_index, token) in tokens.into_iter().enumerate() {
if token_index < index || token_index >= index + consumed {
remaining.push(token);
}
}
Some((
Some(GradientInterpolationMethod { space, hue }),
remaining.join(" "),
))
}
fn parse_linear_gradient_prelude(
value: &str,
) -> Option<Option<(LinearGradientDirection, GradientInterpolationMethod)>> {
let (interpolation, geometry) = split_gradient_interpolation_method(value)?;
if let Some(interpolation) = interpolation {
let direction = if geometry.trim().is_empty() {
LinearGradientDirection::Angle(180.0)
} else {
parse_linear_gradient_direction(&geometry)?
};
return Some(Some((direction, interpolation)));
}
Some(
parse_linear_gradient_direction(&geometry)
.map(|direction| (direction, GradientInterpolationMethod::CSS_IMAGES_3)),
)
}
fn parse_css_angle_degrees(value: &str) -> Option<f32> {
let value = trim_css_value(value);
let mut input = cssparser::ParserInput::new(value);
let mut parser = cssparser::Parser::new(&mut input);
let token = parser.next().ok()?.clone();
let angle = match token {
cssparser::Token::Number { value: 0.0, .. } => 0.0,
cssparser::Token::Dimension { value, unit, .. } if unit.eq_ignore_ascii_case("deg") => {
value
}
cssparser::Token::Dimension { value, unit, .. } if unit.eq_ignore_ascii_case("grad") => {
value * 0.9
}
cssparser::Token::Dimension { value, unit, .. } if unit.eq_ignore_ascii_case("turn") => {
value * 360.0
}
cssparser::Token::Dimension { value, unit, .. } if unit.eq_ignore_ascii_case("rad") => {
value * 180.0 / std::f32::consts::PI
}
_ => return None,
};
parser.is_exhausted().then_some(angle)
}
fn parse_gradient_item(
value: &str,
stops: &mut Vec<GradientColorStop>,
hints: &mut Vec<GradientColorHint>,
) -> Option<()> {
if let Some(position) = parse_deferred_length_percentage(value) {
if stops.is_empty() {
return None;
}
hints.push(GradientColorHint {
after_stop: stops.len() - 1,
position,
});
return Some(());
}
let mut parts = background_components(value)?;
if parts.is_empty() {
return None;
}
let second_position = parts
.last()
.and_then(|part| parse_deferred_length_percentage(part));
let first_position = if second_position.is_some() {
parts.pop();
parts
.last()
.and_then(|part| parse_deferred_length_percentage(part))
} else {
None
};
if first_position.is_some() {
parts.pop();
}
let color_text = parts.join(" ");
let color = parse_gradient_color(&color_text)?;
stops.push(GradientColorStop {
color,
position: first_position.clone().or(second_position.clone()),
});
if let Some(second_position) = first_position.and(second_position) {
stops.push(GradientColorStop {
color,
position: Some(second_position),
});
}
Some(())
}
fn parse_gradient_color(value: &str) -> Option<GradientColor> {
if value.trim().eq_ignore_ascii_case("currentcolor") {
Some(GradientColor::CurrentColor)
} else {
let color = parse_color(value)?;
let (missing, source) = gradient_missing_components(value);
(!missing.is_empty())
.then_some(GradientColor::ColorWithMissing {
color,
missing,
source,
})
.or(Some(GradientColor::CssColor(color)))
}
}
fn gradient_missing_components(
value: &str,
) -> (GradientMissingComponents, GradientMissingComponentSpace) {
let Some((name, body)) = css_single_function(value.trim()) else {
return (
GradientMissingComponents::default(),
GradientMissingComponentSpace::Rgb,
);
};
let name = name.to_ascii_lowercase();
if !matches!(
name.as_str(),
"rgb" | "rgba" | "hsl" | "hsla" | "hwb" | "lab" | "lch" | "oklab" | "oklch" | "color"
) {
return (
GradientMissingComponents::default(),
GradientMissingComponentSpace::Rgb,
);
}
let (components, slash_alpha) = split_css_top_level_once(body, '/')
.map(|(components, alpha)| (components, Some(alpha)))
.unwrap_or((body, None));
let Some(tokens) = try_split_css_top_level_delimiter(components, ',').and_then(|groups| {
groups
.into_iter()
.map(try_split_css_component_values)
.collect::<Option<Vec<_>>>()
.map(|groups| groups.into_iter().flatten().collect::<Vec<_>>())
}) else {
return (
GradientMissingComponents::default(),
GradientMissingComponentSpace::Rgb,
);
};
let component_offset = usize::from(name == "color");
let source = match name.as_str() {
"rgb" | "rgba" => GradientMissingComponentSpace::Rgb,
"hsl" | "hsla" => GradientMissingComponentSpace::Hsl,
"hwb" => GradientMissingComponentSpace::Hwb,
"lab" => GradientMissingComponentSpace::Lab,
"lch" => GradientMissingComponentSpace::Lch,
"oklab" => GradientMissingComponentSpace::Oklab,
"oklch" => GradientMissingComponentSpace::Oklch,
"color" => match tokens
.first()
.and_then(|token| css_single_ident(token))
.map(|ident| ident.to_ascii_lowercase())
.as_deref()
{
Some("xyz") | Some("xyz-d50") | Some("xyz-d65") => GradientMissingComponentSpace::Xyz,
_ => GradientMissingComponentSpace::Rgb,
},
_ => unreachable!("validated gradient color function"),
};
if tokens.len() < component_offset + 3 {
return (GradientMissingComponents::default(), source);
}
let mut bits = 0;
for component in 0..3 {
if css_identifier_is(tokens[component + component_offset], "none") {
bits |= 1 << component;
}
}
if slash_alpha.is_some_and(|alpha| css_identifier_is(alpha, "none"))
|| slash_alpha.is_none()
&& tokens
.get(component_offset + 3)
.is_some_and(|alpha| css_identifier_is(alpha, "none"))
{
bits |= 1 << 3;
}
(GradientMissingComponents::new(bits), source)
}
fn gradient_arguments<'a>(
value: &'a str,
normal_name: &str,
repeating_name: &str,
) -> Option<(bool, Vec<&'a str>)> {
let (name, body) = css_single_function(trim_css_value(value))?;
let repeating = if name.eq_ignore_ascii_case(normal_name) {
false
} else if name.eq_ignore_ascii_case(repeating_name) {
true
} else {
return None;
};
let arguments = try_split_css_top_level_delimiter(body, ',')?;
(!arguments.is_empty() && arguments.iter().all(|argument| !argument.trim().is_empty()))
.then_some((repeating, arguments))
}
fn split_background_position_size(value: &str) -> Option<Option<(String, String)>> {
match split_css_top_level_once(value, '/') {
Some((position, size)) => Some(Some((
strip_background_noise(position)?,
strip_background_noise(size)?,
))),
None => background_components(value).map(|_| None),
}
}
fn strip_background_noise(value: &str) -> Option<String> {
Some(
background_components(value)?
.into_iter()
.filter(|token| {
!css_identifier_is(token, "none")
&& !matches!(parse_css_image(token, None, None), ParsedImage::Image(_))
&& !css_identifier_is(token, "repeat")
&& !css_identifier_is(token, "no-repeat")
&& !css_identifier_is(token, "repeat-x")
&& !css_identifier_is(token, "repeat-y")
&& !matches!(
css_single_ident(token).as_deref(),
Some("scroll" | "fixed" | "local")
)
&& parse_background_box(token).is_none()
&& parse_color_from_currentcolor_in_scheme(
token,
CssColor::BLACK,
UsedColorScheme::Light,
)
.is_none()
&& parse_color(token).is_none()
})
.collect::<Vec<_>>()
.join(" "),
)
}
pub(super) fn background_tokens(value: &str) -> Option<Vec<&str>> {
background_components(value)
}