use cssparser::{Parser, ParserInput, SourcePosition, ToCss, Token, TokenSerializationType};
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct CssComponentValueList {
css: String,
}
impl CssComponentValueList {
pub(crate) fn parse(value: &str) -> Option<Self> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
serialize_component_values(&mut parser)
.ok()
.map(|stream| Self { css: stream.css })
}
pub(crate) fn as_css(&self) -> &str {
&self.css
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ParsedVarArguments {
pub(crate) name_argument: CssComponentValueList,
pub(crate) fallback: Option<CssComponentValueList>,
}
pub(crate) fn parse_var_function_arguments(
parser: &mut Parser<'_, '_>,
) -> Option<ParsedVarArguments> {
let start = parser.position();
let mut comma = None;
while !parser.is_exhausted() {
let token_start = parser.position();
let token = parser
.next_including_whitespace_and_comments()
.ok()?
.clone();
if token.is_parse_error() {
return None;
}
if matches!(token, Token::Comma) && comma.is_none() {
comma = Some((token_start, parser.position()));
continue;
}
if matches!(token, Token::Semicolon | Token::Delim('!')) {
return None;
}
if matches!(token, Token::Function(ref name) if name.eq_ignore_ascii_case("var")) {
if parser
.parse_nested_block(|nested| {
parse_var_function_arguments(nested)
.ok_or_else(|| nested.new_custom_error::<(), ()>(()))
})
.is_err()
{
return None;
}
} else if is_simple_block(&token) && !consume_nested_block(parser) {
return None;
}
}
let (name_source, fallback_source) = if let Some((comma_start, fallback_start)) = comma {
(
parser.slice(start..comma_start),
Some(parser.slice_from(fallback_start)),
)
} else {
(parser.slice_from(start), None)
};
let name_argument = parse_var_name_argument(name_source)?;
let fallback = match fallback_source {
Some(source) => Some(CssComponentValueList::parse(source)?),
None => None,
};
Some(ParsedVarArguments {
name_argument,
fallback,
})
}
fn parse_var_name_argument(value: &str) -> Option<CssComponentValueList> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let mut significant = 0usize;
let mut curly_contents = None;
while !parser.is_exhausted() {
let token = parser
.next_including_whitespace_and_comments()
.ok()?
.clone();
if token.is_parse_error() || matches!(token, Token::Semicolon | Token::Delim('!')) {
return None;
}
if matches!(token, Token::WhiteSpace(_) | Token::Comment(_)) {
continue;
}
significant += 1;
if matches!(token, Token::CurlyBracketBlock) {
let contents = parser
.parse_nested_block(|nested| {
serialize_component_values(nested)
.map(|value| value.css)
.map_err(|_| nested.new_custom_error::<(), ()>(()))
})
.ok()?;
curly_contents = Some(contents);
} else if is_simple_block(&token) && !consume_nested_block(&mut parser) {
return None;
}
}
if significant == 0 || (curly_contents.is_some() && significant != 1) {
return None;
}
CssComponentValueList::parse(curly_contents.as_deref().unwrap_or(value))
}
pub(crate) fn validate_component_value_list_from_parser(parser: &mut Parser<'_, '_>) -> bool {
while !parser.is_exhausted() {
let Ok(token) = parser.next_including_whitespace_and_comments() else {
return false;
};
if token.is_parse_error() || (is_simple_block(token) && !consume_nested_block(parser)) {
return false;
}
}
true
}
#[derive(Default)]
struct SerializedComponentValues {
css: String,
last_token_type: TokenSerializationType,
}
impl SerializedComponentValues {
fn push_component(&mut self, css: &str, token_type: TokenSerializationType) {
if self.last_token_type.needs_separator_when_before(token_type) {
self.css.push_str("/**/");
}
self.css.push_str(css);
self.last_token_type = token_type;
}
}
fn serialize_component_values(
parser: &mut Parser<'_, '_>,
) -> Result<SerializedComponentValues, ()> {
let mut output = SerializedComponentValues::default();
while !parser.is_exhausted() {
let token = parser
.next_including_whitespace_and_comments()
.map_err(|_| ())?;
if token.is_parse_error() {
return Err(());
}
let token = token.clone();
let token_type = token.serialization_type();
let css = match token {
Token::Function(_) => {
let mut css = token.to_css_string();
let nested = parser
.parse_nested_block(|nested| {
serialize_component_values(nested)
.map_err(|_| nested.new_custom_error::<(), ()>(()))
})
.map_err(|_| ())?;
css.push_str(&nested.css);
css.push(')');
css
}
Token::ParenthesisBlock => {
let mut css = token.to_css_string();
let nested = parser
.parse_nested_block(|nested| {
serialize_component_values(nested)
.map_err(|_| nested.new_custom_error::<(), ()>(()))
})
.map_err(|_| ())?;
css.push_str(&nested.css);
css.push(')');
css
}
Token::SquareBracketBlock => {
let mut css = token.to_css_string();
let nested = parser
.parse_nested_block(|nested| {
serialize_component_values(nested)
.map_err(|_| nested.new_custom_error::<(), ()>(()))
})
.map_err(|_| ())?;
css.push_str(&nested.css);
css.push(']');
css
}
Token::CurlyBracketBlock => {
let mut css = token.to_css_string();
let nested = parser
.parse_nested_block(|nested| {
serialize_component_values(nested)
.map_err(|_| nested.new_custom_error::<(), ()>(()))
})
.map_err(|_| ())?;
css.push_str(&nested.css);
css.push('}');
css
}
_ => token.to_css_string(),
};
output.push_component(&css, token_type);
}
Ok(output)
}
fn consume_nested_block(parser: &mut Parser<'_, '_>) -> bool {
parser
.parse_nested_block(|nested| {
if validate_component_value_list_from_parser(nested) {
Ok::<_, cssparser::ParseError<'_, ()>>(())
} else {
Err(nested.new_custom_error(()))
}
})
.is_ok()
}
fn is_simple_block(token: &Token<'_>) -> bool {
matches!(
token,
Token::Function(_)
| Token::ParenthesisBlock
| Token::SquareBracketBlock
| Token::CurlyBracketBlock
)
}
fn source_offset(parser: &Parser<'_, '_>, source_start: SourcePosition) -> usize {
parser.slice_from(source_start).len()
}
pub(crate) fn trim_css_value(value: &str) -> &str {
let value = value.trim();
let important = "!important";
let suffix_start = value.len().saturating_sub(important.len());
if let Some(suffix) = value.get(suffix_start..)
&& suffix.eq_ignore_ascii_case(important)
{
value.get(..suffix_start).unwrap_or(value).trim_end()
} else {
value
}
}
pub(crate) fn parse_css_string_token(value: &str) -> Option<(String, &str)> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let token = parser.next().ok()?.clone();
let Token::QuotedString(text) = token else {
return None;
};
Some((
text.to_string(),
trim_css_component_value_start(&value[parser.position().byte_index()..]),
))
}
pub(crate) fn trim_css_component_value_start(value: &str) -> &str {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
loop {
let token_start = parser.position().byte_index();
match parser.next_including_whitespace_and_comments() {
Ok(Token::WhiteSpace(_) | Token::Comment(_)) => {}
Ok(_) => return &value[token_start..],
Err(_) => return &value[value.len()..],
}
}
}
pub(crate) fn trim_css_component_value_edges(value: &str) -> &str {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let mut first = None;
let mut last = 0;
loop {
let token_start = parser.position().byte_index();
let token = match parser.next_including_whitespace_and_comments() {
Ok(token) => token,
Err(_) => break,
};
let is_ignorable = matches!(token, Token::WhiteSpace(_) | Token::Comment(_));
if !is_ignorable && is_simple_block(token) && !consume_nested_block(&mut parser) {
return value;
}
let token_end = parser.position().byte_index();
if !is_ignorable {
first.get_or_insert(token_start);
last = token_end;
}
}
first.map_or(&value[value.len()..], |first| &value[first..last])
}
pub(crate) fn split_css_component_values(value: &str) -> Vec<&str> {
try_split_css_component_values(value).unwrap_or_default()
}
pub(in crate::css) fn try_split_css_component_values(value: &str) -> Option<Vec<&str>> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let mut parts = Vec::new();
let mut component_start = None;
while !parser.is_exhausted() {
let token_start = parser.position();
let token = parser
.next_including_whitespace_and_comments()
.ok()?
.clone();
if token.is_parse_error() {
return None;
}
if matches!(token, Token::WhiteSpace(_) | Token::Comment(_)) {
if let Some(start) = component_start.take() {
let part = parser.slice(start..token_start).trim();
if !part.is_empty() {
parts.push(part);
}
}
continue;
}
component_start.get_or_insert(token_start);
if is_simple_block(&token) && !consume_nested_block(&mut parser) {
return None;
}
}
if let Some(start) = component_start {
let part = parser.slice_from(start).trim();
if !part.is_empty() {
parts.push(part);
}
}
Some(parts)
}
pub(crate) fn split_css_top_level_delimiter(value: &str, delimiter: char) -> Vec<&str> {
try_split_css_top_level_delimiter(value, delimiter).unwrap_or_default()
}
pub(in crate::css) fn try_split_css_top_level_delimiter(
value: &str,
delimiter: char,
) -> Option<Vec<&str>> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let mut parts = Vec::new();
let source_start = parser.position();
let mut start = 0usize;
while !parser.is_exhausted() {
let token_start = source_offset(&parser, source_start);
let token = parser
.next_including_whitespace_and_comments()
.ok()?
.clone();
if token.is_parse_error() {
return None;
}
let is_delimiter = matches!(token, Token::Comma) && delimiter == ','
|| matches!(token, Token::Delim(found) if found == delimiter);
if is_delimiter {
parts.push(value[start..token_start].trim());
start = source_offset(&parser, source_start);
} else if is_simple_block(&token) && !consume_nested_block(&mut parser) {
return None;
}
}
parts.push(value[start..].trim());
Some(parts)
}
pub(in crate::css) fn split_nonempty_css_top_level_delimiter(
value: &str,
delimiter: char,
) -> Vec<&str> {
split_css_top_level_delimiter(value, delimiter)
.into_iter()
.map(trim_css_value)
.filter(|part| !part.is_empty())
.collect()
}
pub(in crate::css) fn css_function_list(value: &str) -> Option<Vec<(String, &str)>> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let mut functions = Vec::new();
while !parser.is_exhausted() {
let token = parser
.next_including_whitespace_and_comments()
.ok()?
.clone();
if matches!(token, Token::WhiteSpace(_) | Token::Comment(_)) {
continue;
}
let Token::Function(name) = token else {
return None;
};
let body = parser
.parse_nested_block(|nested| {
let start = nested.position();
while let Ok(token) = nested.next_including_whitespace_and_comments() {
if token.is_parse_error()
|| (is_simple_block(token) && !consume_nested_block(nested))
{
return Err(nested.new_custom_error(()));
}
}
if nested.is_exhausted() {
Ok::<_, cssparser::ParseError<'_, ()>>(nested.slice_from(start))
} else {
Err(nested.new_custom_error(()))
}
})
.ok()?;
functions.push((name.to_string(), body));
}
Some(functions)
}
pub(in crate::css) fn split_css_top_level_once(
value: &str,
delimiter: char,
) -> Option<(&str, &str)> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let source_start = parser.position();
let start = 0usize;
loop {
let token_start = source_offset(&parser, source_start);
let token = parser
.next_including_whitespace_and_comments()
.ok()?
.clone();
let is_delimiter = matches!(token, Token::Comma) && delimiter == ','
|| matches!(token, Token::Delim(found) if found == delimiter);
if is_delimiter {
return Some((
value[start..token_start].trim(),
&value[source_offset(&parser, source_start)..],
));
}
if is_simple_block(&token) && !consume_nested_block(&mut parser) {
return None;
}
}
}
pub(in crate::css) fn css_single_function(value: &str) -> Option<(String, &str)> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let name = match parser.next().ok()? {
Token::Function(name) => name.to_string(),
_ => return None,
};
let body = parser
.parse_nested_block(|nested| {
let start = nested.position();
while let Ok(token) = nested.next_including_whitespace_and_comments() {
if token.is_parse_error()
|| (is_simple_block(token) && !consume_nested_block(nested))
{
return Err(nested.new_custom_error(()));
}
}
Ok::<_, cssparser::ParseError<'_, ()>>(nested.slice_from(start))
})
.ok()?;
parser.is_exhausted().then_some((name, body))
}
pub(crate) fn css_leading_function(value: &str) -> Option<(String, &str, &str)> {
let value = value.trim_start();
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let name = match parser.next().ok()? {
Token::Function(name) => name.to_string(),
_ => return None,
};
let body = parser
.parse_nested_block(|nested| {
let start = nested.position();
while let Ok(token) = nested.next_including_whitespace_and_comments() {
if token.is_parse_error()
|| (is_simple_block(token) && !consume_nested_block(nested))
{
return Err(nested.new_custom_error(()));
}
}
Ok::<_, cssparser::ParseError<'_, ()>>(nested.slice_from(start))
})
.ok()?;
Some((name, body, &value[parser.position().byte_index()..]))
}
pub(crate) fn css_leading_function_matching<'a>(
value: &'a str,
expected_name: &str,
) -> Option<(&'a str, &'a str)> {
let (name, body, tail) = css_leading_function(value)?;
name.eq_ignore_ascii_case(expected_name)
.then_some((body, tail))
}
pub(crate) fn css_leading_ident(value: &str) -> Option<(String, &str)> {
let value = trim_css_component_value_start(value);
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let ident = parser.expect_ident_cloned().ok()?.to_string();
Some((ident, &value[parser.position().byte_index()..]))
}
pub(crate) fn css_image_candidate_urls(value: &str) -> Vec<String> {
let mut urls = Vec::new();
collect_css_image_candidate_urls(value, &mut urls);
urls
}
fn collect_css_image_candidate_urls(value: &str, urls: &mut Vec<String>) {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
while let Ok(token) = parser.next_including_whitespace_and_comments() {
let token = token.clone();
match token {
Token::UnquotedUrl(url) => {
if !url.is_empty() {
urls.push(url.to_string());
}
}
Token::Function(name) => {
let name = name.to_string();
let _ = parser.parse_nested_block(
|nested| -> Result<(), cssparser::ParseError<'_, ()>> {
let start = nested.position();
while let Ok(token) = nested.next_including_whitespace_and_comments() {
if is_simple_block(token) && !consume_nested_block(nested) {
return Err(nested.new_custom_error(()));
}
}
let body = nested.slice_from(start);
if name.eq_ignore_ascii_case("url") {
if let Some((url, _)) = parse_css_string_token(body.trim()) {
if !url.is_empty() {
urls.push(url);
}
} else if let Some(url) = css_single_ident(body)
&& !url.is_empty()
{
urls.push(url);
}
}
if name.eq_ignore_ascii_case("image-set")
|| name.eq_ignore_ascii_case("-webkit-image-set")
{
for option in split_css_top_level_delimiter(body, ',') {
let components = split_css_component_values(option);
let Some(source) = components.first() else {
continue;
};
if let Some((url, tail)) = parse_css_string_token(source)
&& tail.trim().is_empty()
&& !url.is_empty()
{
urls.push(url);
}
}
}
if !name.eq_ignore_ascii_case("type") {
collect_css_image_candidate_urls(body, urls);
}
Ok(())
},
);
}
Token::ParenthesisBlock | Token::SquareBracketBlock | Token::CurlyBracketBlock => {
let _ = parser.parse_nested_block(
|nested| -> Result<(), cssparser::ParseError<'_, ()>> {
let start = nested.position();
while let Ok(token) = nested.next_including_whitespace_and_comments() {
if is_simple_block(token) && !consume_nested_block(nested) {
return Err(nested.new_custom_error(()));
}
}
collect_css_image_candidate_urls(nested.slice_from(start), urls);
Ok(())
},
);
}
_ => {}
}
}
}
pub(in crate::css) fn css_function_body<'a>(value: &'a str, name: &str) -> Option<&'a str> {
let (actual, body) = css_single_function(value)?;
actual.eq_ignore_ascii_case(name).then_some(body)
}
pub(crate) fn css_single_ident(value: &str) -> Option<String> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let ident = parser.expect_ident_cloned().ok()?.to_string();
parser.is_exhausted().then_some(ident)
}
pub(in crate::css) fn split_css_top_level_keyword<'a>(
value: &'a str,
keyword: &str,
) -> Vec<&'a str> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let mut parts = Vec::new();
let source_start = parser.position();
let mut start = 0usize;
loop {
let token_start = source_offset(&parser, source_start);
let token = match parser.next_including_whitespace_and_comments() {
Ok(token) => token.clone(),
Err(_) => break,
};
if matches!(token, Token::Ident(ref name) if name.eq_ignore_ascii_case(keyword)) {
parts.push(value[start..token_start].trim());
start = source_offset(&parser, source_start);
} else if is_simple_block(&token) && !consume_nested_block(&mut parser) {
break;
}
}
parts.push(value[start..].trim());
parts
}
pub(in crate::css) fn find_css_top_level_keyword_range(
value: &str,
keyword: &str,
) -> Option<std::ops::Range<usize>> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
while !parser.is_exhausted() {
let start = parser.position().byte_index();
let token = parser
.next_including_whitespace_and_comments()
.ok()?
.clone();
if token.is_parse_error() {
return None;
}
if matches!(token, Token::Ident(ref name) if name.eq_ignore_ascii_case(keyword)) {
return Some(start..parser.position().byte_index());
}
if is_simple_block(&token) && !consume_nested_block(&mut parser) {
return None;
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
fn parse_var_arguments(value: &str) -> Option<ParsedVarArguments> {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
let token = parser.next().ok()?.clone();
matches!(token, Token::Function(ref name) if name.eq_ignore_ascii_case("var"))
.then(|| ())?;
parser
.parse_nested_block(|nested| {
parse_var_function_arguments(nested)
.ok_or_else(|| nested.new_custom_error::<(), ()>(()))
})
.ok()
}
#[test]
fn var_arguments_preserve_the_free_form_name_and_empty_fallback() {
let empty_fallback = parse_var_arguments("var(--name,)").expect("valid var()");
assert_eq!(empty_fallback.name_argument.as_css(), "--name");
assert_eq!(
empty_fallback.fallback.expect("present fallback").as_css(),
""
);
let nested_name =
parse_var_arguments("var(var(--name), red, blue)").expect("nested name argument");
assert_eq!(nested_name.name_argument.as_css(), "var(--name)");
assert_eq!(
nested_name.fallback.expect("fallback").as_css(),
" red, blue"
);
let braced_name = parse_var_arguments("var({ --name })").expect("braced name");
assert_eq!(braced_name.name_argument.as_css(), " --name");
}
#[test]
fn var_arguments_reject_invalid_free_form_structure() {
for value in [
"var()",
"var(, red)",
"var({--name} extra)",
"var(--name, !important)",
"var(--name; red)",
] {
assert!(parse_var_arguments(value).is_none(), "{value}");
}
}
#[test]
fn component_value_stream_rejects_css_syntax_error_tokens() {
for value in ["red)", "var(--color, \"\n", "var(--color, url(\"\n"] {
assert!(CssComponentValueList::parse(value).is_none(), "{value}");
}
}
#[test]
fn component_value_stream_accepts_balanced_blocks_and_cdo_cdc() {
for value in [
"{ [ var(--color) ] }",
"var(--color) <!--",
"--> var(--color)",
] {
assert!(CssComponentValueList::parse(value).is_some(), "{value}");
}
}
#[test]
fn borrowed_component_value_validation_matches_component_value_syntax() {
for (value, valid) in [
("{ [ var(--color) ] }", true),
("var(--color, calc(1px + 2px)", true),
("red)", false),
("var(--color, \"\n", false),
("var(--color, url(\"\n", false),
] {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
assert_eq!(
validate_component_value_list_from_parser(&mut parser),
valid,
"{value}"
);
}
}
#[test]
fn component_boundaries_follow_css_tokens() {
assert_eq!(
split_css_component_values("solid /* separator */ rgb(1 2 3) 'x y'"),
["solid", "rgb(1 2 3)", "'x y'"]
);
assert_eq!(
split_css_component_values("foo/**/bar 1/**/2px"),
["foo", "bar", "1", "2px"]
);
assert_eq!(
split_css_top_level_delimiter("a, func(1, 2), 'x,y'", ','),
["a", "func(1, 2)", "'x,y'"]
);
assert_eq!(
split_css_top_level_once("rgb(1 / 2 / 3) / .5", '/'),
Some(("rgb(1 / 2 / 3)", " .5"))
);
assert_eq!(
split_nonempty_css_top_level_delimiter("first, , func(1, 2), ", ','),
["first", "func(1, 2)"]
);
}
#[test]
fn strict_value_boundaries_reject_invalid_prefixes() {
for value in ["red)", "url(\"\n"] {
assert!(try_split_css_component_values(value).is_none(), "{value}");
assert!(
try_split_css_top_level_delimiter(value, ',').is_none(),
"{value}"
);
}
assert_eq!(split_css_component_values("red)"), Vec::<&str>::new());
assert_eq!(
try_split_css_component_values("calc(1px"),
Some(vec!["calc(1px"])
);
assert_eq!(
try_split_css_top_level_delimiter(r#"url("a,b"), c"#, ','),
Some(vec![r#"url("a,b")"#, "c"])
);
}
#[test]
fn css_function_lists_decode_names_and_preserve_token_boundaries() {
let functions = css_function_list(r"tr\61 nslate(10px/**/, 20px) /**/ sc\61 le(2)")
.expect("valid CSS function list");
assert_eq!(
functions,
vec![
("translate".to_owned(), "10px/**/, 20px"),
("scale".to_owned(), "2"),
]
);
assert!(css_function_list("scale(2) nope").is_none());
assert!(css_function_list("scale(2").is_some());
}
#[test]
fn token_consumers_ignore_comment_boundaries() {
let (text, tail) = parse_css_string_token("/**/\"hello\"/**/ \"there\"")
.expect("comment-delimited string token");
assert_eq!(text, "hello");
assert_eq!(tail, "\"there\"");
assert_eq!(trim_css_component_value_edges("/**/10px/**/"), "10px");
assert_eq!(
trim_css_component_value_edges("/**/calc(1px)/**/"),
"calc(1px)"
);
assert_eq!(trim_css_component_value_edges("foo/**/bar"), "foo/**/bar");
assert_eq!(
split_css_top_level_delimiter("/**/Ahem/**/,/**/sans-serif/**/", ','),
["/**/Ahem/**/", "/**/sans-serif/**/"]
);
}
#[test]
fn identifiers_and_functions_are_decoded_before_matching() {
assert_eq!(
css_single_ident("\\74 ransparent"),
Some("transparent".into())
);
assert_eq!(
css_single_function("\\72 gb(1 2 3)"),
Some(("rgb".into(), "1 2 3"))
);
assert_eq!(
split_css_top_level_keyword("(a and b) \\61 nd c", "and"),
["(a and b)", "c"]
);
}
#[test]
fn image_candidate_urls_follow_component_value_boundaries() {
assert_eq!(
css_image_candidate_urls(
r#"image-set("a\2epng" 1x type("image/png"), linear-gradient(red, blue) 2x, url("c.png") 3x)"#,
),
["a.png", "c.png"]
);
assert_eq!(
css_image_candidate_urls(r#"image-set(image(url("nested.png")) 1x type("not-a-url"))"#),
["nested.png"]
);
}
}