Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

40.9 KB
Raw Blame
use cssparser::{ParseError, Parser, Token, parse_nth, serialize_identifier, serialize_string};

use moli_css_parse::serialize_component_values_single_line;

fn css_parse_error(error: cssparser::BasicParseError) -> ParseError<()> {
    error.into()
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CssDirection {
    Ltr,
    Rtl,
}

impl CssDirection {
    pub fn as_str(self) -> &'static str {
        match self {
            Self::Ltr => "ltr",
            Self::Rtl => "rtl",
        }
    }
}

pub fn first_strong_text_direction(value: &str) -> Option<CssDirection> {
    value.chars().find_map(strong_char_direction)
}

fn strong_char_direction(ch: char) -> Option<CssDirection> {
    if is_rtl_strong_char(ch) {
        Some(CssDirection::Rtl)
    } else if ch.is_alphabetic() {
        Some(CssDirection::Ltr)
    } else {
        None
    }
}

fn is_rtl_strong_char(ch: char) -> bool {
    matches!(
        ch as u32,
        0x0590..=0x08ff | 0xfb1d..=0xfdff | 0xfe70..=0xfefc | 0x10800..=0x10fff
    )
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum GetComputedStylePseudoElement {
    OriginatingElement,
    EmptyStyle,
    PseudoElement(String),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum CssAttributeSelectorOperator {
    Exists,
    Equals,
    Includes,
    DashMatch,
    Prefix,
    Suffix,
    Substring,
}

#[derive(Debug, Clone, PartialEq, Eq)]
struct CssAttributeSelector {
    name: String,
    operator: CssAttributeSelectorOperator,
    expected: Option<String>,
}

pub(crate) fn selector_list_has_namespace_separator(selector_text: &str) -> bool {
    let input = selector_text;
    let mut input = Parser::new(input);
    selector_tokens_have_namespace_separator(&mut input)
}

pub(crate) fn selector_list_namespace_prefixes(selector_text: &str) -> Vec<String> {
    let input = selector_text;
    let mut input = Parser::new(input);
    let mut prefixes = Vec::new();
    collect_selector_namespace_prefixes(&mut input, &mut prefixes);
    prefixes
}

fn parse_css_attribute_selector(selector_text: &str) -> Option<CssAttributeSelector> {
    let input = selector_text;
    let mut parser = Parser::new(input);
    parser
        .parse_entirely(|parser| {
            parser
                .expect_square_bracket_block()
                .map_err(css_parse_error)?;
            parser.parse_nested_block(parse_css_attribute_selector_block)
        })
        .ok()
}

fn parse_css_attribute_selector_block<'i>(
    input: &mut Parser<'i>,
) -> Result<CssAttributeSelector, ParseError<()>> {
    let name = input.expect_ident_cloned().map_err(css_parse_error)?;
    if input.is_exhausted() {
        return Ok(CssAttributeSelector {
            name: name.to_string(),
            operator: CssAttributeSelectorOperator::Exists,
            expected: None,
        });
    }

    let operator = match input.next().map_err(css_parse_error)? {
        Token::Delim('=') => CssAttributeSelectorOperator::Equals,
        Token::IncludeMatch => CssAttributeSelectorOperator::Includes,
        Token::DashMatch => CssAttributeSelectorOperator::DashMatch,
        Token::PrefixMatch => CssAttributeSelectorOperator::Prefix,
        Token::SuffixMatch => CssAttributeSelectorOperator::Suffix,
        Token::SubstringMatch => CssAttributeSelectorOperator::Substring,
        _ => return Err(cssparser::ParseError::custom(())),
    };
    let expected = input
        .expect_ident_or_string()
        .map_err(css_parse_error)?
        .as_ref()
        .to_owned();
    if !input.is_exhausted() {
        return Err(cssparser::ParseError::custom(()));
    }

    Ok(CssAttributeSelector {
        name: name.to_string(),
        operator,
        expected: Some(expected),
    })
}

pub(crate) fn serialize_cssom_selector_text(
    selector_text: &str,
    has_default_namespace: bool,
    prefixes_matching_default_namespace: &[String],
) -> Option<String> {
    let selector_text = serialize_component_values_single_line(selector_text)?;
    Some(serialize_cssom_selector_text_from_single_line(
        &selector_text,
        has_default_namespace,
        prefixes_matching_default_namespace,
    ))
}

fn serialize_cssom_selector_text_without_default_namespace(selector_text: &str) -> Option<String> {
    serialize_cssom_selector_text(selector_text, false, &[])
}

fn serialize_cssom_selector_text_from_single_line(
    selector_text: &str,
    has_default_namespace: bool,
    prefixes_matching_default_namespace: &[String],
) -> String {
    let mut output = String::with_capacity(selector_text.len());
    let mut index = 0;
    let mut at_compound_start = true;
    while index < selector_text.len() {
        let rest = &selector_text[index..];
        if rest.starts_with('[')
            && let Some((attribute, next_index)) =
                serialize_attribute_selector(selector_text, index)
        {
            output.push_str(&attribute);
            index = next_index;
            at_compound_start = false;
            continue;
        }
        if at_compound_start && !has_default_namespace && rest.starts_with("*|") {
            index += 2;
            continue;
        }
        if at_compound_start
            && let Some(prefix) =
                redundant_default_namespace_prefix(rest, prefixes_matching_default_namespace)
        {
            index += prefix.len() + 1;
            continue;
        }
        if at_compound_start
            && rest.starts_with('*')
            && rest
                .as_bytes()
                .get(1)
                .is_some_and(|next| matches!(next, b'.' | b'#' | b':' | b'['))
        {
            index += 1;
            continue;
        }
        if !output.ends_with(':')
            && rest.starts_with(':')
            && !rest.starts_with("::")
            && let Some((pseudo_element, next_index)) =
                legacy_pseudo_element_name(selector_text, index + 1)
        {
            output.push_str("::");
            output.push_str(pseudo_element);
            index = next_index;
            at_compound_start = false;
            continue;
        }
        if rest.starts_with(':')
            && let Some((nth_selector, next_index)) =
                serialize_nth_pseudo_class(selector_text, index)
        {
            output.push_str(&nth_selector);
            index = next_index;
            at_compound_start = false;
            continue;
        }
        if rest.starts_with(':')
            && let Some((pseudo_class, next_index)) =
                serialize_functional_selector_list_pseudo_class(selector_text, index)
        {
            output.push_str(&pseudo_class);
            index = next_index;
            at_compound_start = false;
            continue;
        }

        let ch = rest.chars().next().expect("non-empty selector remainder");
        output.push(ch);
        index += ch.len_utf8();
        at_compound_start = matches!(ch, ',' | '>' | '+' | '~' | ' ');
    }
    output
}

fn serialize_attribute_selector(selector_text: &str, open_index: usize) -> Option<(String, usize)> {
    let close_offset = selector_text[open_index..].find(']')?;
    let close_index = open_index + close_offset;
    let content = &selector_text[open_index + 1..close_index];
    if let Some(serialized) = serialize_attribute_selector_content(content) {
        return Some((serialized, close_index + 1));
    }
    let mut output = String::with_capacity(close_offset + 1);
    output.push('[');
    output.push_str(content.strip_prefix('|').unwrap_or(content));
    output.push(']');
    Some((output, close_index + 1))
}

fn serialize_attribute_selector_content(content: &str) -> Option<String> {
    let selector = parse_css_attribute_selector(&format!("[{content}]"))?;
    let mut output = String::new();
    output.push('[');
    serialize_identifier(&selector.name, &mut output).ok()?;
    if let Some(expected) = selector.expected.as_deref() {
        output.push_str(match selector.operator {
            CssAttributeSelectorOperator::Exists => return None,
            CssAttributeSelectorOperator::Equals => "=",
            CssAttributeSelectorOperator::Includes => "~=",
            CssAttributeSelectorOperator::DashMatch => "|=",
            CssAttributeSelectorOperator::Prefix => "^=",
            CssAttributeSelectorOperator::Suffix => "$=",
            CssAttributeSelectorOperator::Substring => "*=",
        });
        serialize_string(expected, &mut output).ok()?;
    }
    output.push(']');
    Some(output)
}

fn redundant_default_namespace_prefix<'a>(
    selector_text: &'a str,
    prefixes_matching_default_namespace: &[String],
) -> Option<&'a str> {
    let (prefix, rest) = selector_text.split_once('|')?;
    if prefix.is_empty()
        || prefix == "*"
        || !prefixes_matching_default_namespace
            .iter()
            .any(|existing| existing == prefix)
    {
        return None;
    }
    rest.chars()
        .next()
        .is_some_and(|ch| ch == '*' || is_identifier_start(ch))
        .then_some(prefix)
}

fn legacy_pseudo_element_name(selector_text: &str, name_index: usize) -> Option<(&str, usize)> {
    let name = ["after", "before", "first-letter", "first-line"]
        .into_iter()
        .find(|name| {
            selector_text[name_index..].starts_with(name)
                && selector_text[name_index + name.len()..]
                    .chars()
                    .next()
                    .is_none_or(|ch| !is_identifier_continue(ch))
        })?;
    Some((
        &selector_text[name_index..name_index + name.len()],
        name_index + name.len(),
    ))
}

fn serialize_nth_pseudo_class(selector_text: &str, colon_index: usize) -> Option<(String, usize)> {
    let rest = &selector_text[colon_index + 1..];
    let name = [
        "nth-child",
        "nth-last-child",
        "nth-of-type",
        "nth-last-of-type",
    ]
    .into_iter()
    .find(|name| rest.starts_with(*name) && rest.as_bytes().get(name.len()) == Some(&b'('))?;
    let open_index = colon_index + 1 + name.len();
    let close_index = matching_close_parenthesis(selector_text, open_index)?;
    let argument = &selector_text[open_index + 1..close_index];
    let (step, offset) = parse_nth_argument(argument)?;
    Some((
        format!(":{name}({})", serialize_an_plus_b(step, offset)),
        close_index + 1,
    ))
}

fn serialize_functional_selector_list_pseudo_class(
    selector_text: &str,
    colon_index: usize,
) -> Option<(String, usize)> {
    let rest = &selector_text[colon_index + 1..];
    let name = ["is", "where", "not"]
        .into_iter()
        .find(|name| rest.starts_with(*name) && rest.as_bytes().get(name.len()) == Some(&b'('))?;
    let open_index = colon_index + 1 + name.len();
    let close_index = matching_close_parenthesis(selector_text, open_index)?;
    let argument = &selector_text[open_index + 1..close_index];
    let argument = serialize_selector_list_function_argument(argument)?;
    Some((format!(":{name}({argument})"), close_index + 1))
}

fn serialize_selector_list_function_argument(argument: &str) -> Option<String> {
    let items = top_level_comma_separated_selector_items(argument)?;
    Some(
        items
            .into_iter()
            .map(|item| serialize_cssom_selector_text_without_default_namespace(item.trim()))
            .collect::<Option<Vec<_>>>()?
            .join(", "),
    )
}

fn top_level_comma_separated_selector_items(argument: &str) -> Option<Vec<&str>> {
    let mut items = Vec::new();
    let mut start = 0;
    let mut bracket_depth = 0_u32;
    let mut paren_depth = 0_u32;
    let mut quote = None;
    let mut escaped = false;
    for (index, ch) in argument.char_indices() {
        if let Some(current_quote) = quote {
            if escaped {
                escaped = false;
            } else if ch == '\\' {
                escaped = true;
            } else if ch == current_quote {
                quote = None;
            }
            continue;
        }
        match ch {
            '"' | '\'' => quote = Some(ch),
            '[' => bracket_depth = bracket_depth.saturating_add(1),
            ']' => bracket_depth = bracket_depth.checked_sub(1)?,
            '(' => paren_depth = paren_depth.saturating_add(1),
            ')' => paren_depth = paren_depth.checked_sub(1)?,
            ',' if bracket_depth == 0 && paren_depth == 0 => {
                let item = argument[start..index].trim();
                if item.is_empty() {
                    return None;
                }
                items.push(item);
                start = index + 1;
            }
            _ => {}
        }
    }
    if quote.is_some() || bracket_depth != 0 || paren_depth != 0 {
        return None;
    }
    let item = argument[start..].trim();
    if item.is_empty() {
        return None;
    }
    items.push(item);
    Some(items)
}

fn matching_close_parenthesis(selector_text: &str, open_index: usize) -> Option<usize> {
    let mut depth = 0_u32;
    for (index, ch) in selector_text[open_index..].char_indices() {
        match ch {
            '(' => depth = depth.saturating_add(1),
            ')' => {
                depth = depth.checked_sub(1)?;
                if depth == 0 {
                    return Some(open_index + index);
                }
            }
            _ => {}
        }
    }
    None
}

fn parse_nth_argument(argument: &str) -> Option<(i32, i32)> {
    let input = argument;
    let mut parser = Parser::new(input);
    let parsed = parse_nth(&mut parser).ok()?;
    parser.is_exhausted().then_some(parsed)
}

fn serialize_an_plus_b(step: i32, offset: i32) -> String {
    match (step, offset) {
        (0, 0) => "0".to_owned(),
        (1, 0) => "n".to_owned(),
        (-1, 0) => "-n".to_owned(),
        (_, 0) => format!("{step}n"),
        (0, _) => offset.to_string(),
        (1, _) => format!("n{offset:+}"),
        (-1, _) => format!("-n{offset:+}"),
        (_, _) => format!("{step}n{offset:+}"),
    }
}

fn is_identifier_start(ch: char) -> bool {
    ch == '_' || ch == '-' || ch.is_ascii_alphabetic() || !ch.is_ascii()
}

fn is_identifier_continue(ch: char) -> bool {
    is_identifier_start(ch) || ch.is_ascii_digit()
}

fn selector_tokens_have_namespace_separator(input: &mut Parser<'_>) -> bool {
    let mut found = false;
    while let Ok(token) = input.next_including_whitespace_and_comments().cloned() {
        match token {
            Token::Delim('|') => found = true,
            Token::Function(_)
            | Token::ParenthesisBlock
            | Token::SquareBracketBlock
            | Token::CurlyBracketBlock => {
                let _ = input.parse_nested_block(|input| {
                    found |= selector_tokens_have_namespace_separator(input);
                    Ok::<_, cssparser::ParseError<()>>(())
                });
            }
            _ => {}
        }
    }
    found
}

fn collect_selector_namespace_prefixes(input: &mut Parser<'_>, prefixes: &mut Vec<String>) {
    let mut previous_prefix_candidate: Option<String> = None;
    while let Ok(token) = input.next_including_whitespace_and_comments().cloned() {
        match token {
            Token::Ident(name) => {
                previous_prefix_candidate = Some(name.to_string());
            }
            Token::Delim('*') => {
                previous_prefix_candidate = None;
            }
            Token::Delim('|') => {
                if let Some(prefix) = previous_prefix_candidate.take()
                    && !prefixes.iter().any(|existing| existing == &prefix)
                {
                    prefixes.push(prefix);
                }
            }
            Token::Function(_) | Token::ParenthesisBlock | Token::CurlyBracketBlock => {
                previous_prefix_candidate = None;
                let _ = input.parse_nested_block(|input| {
                    collect_selector_namespace_prefixes(input, prefixes);
                    Ok::<_, cssparser::ParseError<()>>(())
                });
            }
            Token::SquareBracketBlock => {
                previous_prefix_candidate = None;
                let _ = consume_nested_component_value(input, &token);
            }
            _ => {
                previous_prefix_candidate = None;
            }
        }
    }
}

pub(crate) fn dom_api_selector_text_with_trailing_attribute_recovery(
    selector_text: &str,
) -> String {
    if !selector_text.contains('[') {
        return selector_text.to_owned();
    }
    if let Some(open_index) = trailing_unclosed_attribute_selector_index(selector_text)
        && selector_text[open_index + 1..].contains('=')
    {
        let mut recovered = String::with_capacity(selector_text.len() + 1);
        recovered.push_str(selector_text);
        recovered.push(']');
        return recovered;
    }
    selector_text.to_owned()
}

fn trailing_unclosed_attribute_selector_index(selector_text: &str) -> Option<usize> {
    let mut quote = None;
    let mut bracket_stack = Vec::new();
    for (index, ch) in selector_text.char_indices() {
        match ch {
            '"' | '\'' => {
                if quote == Some(ch) {
                    quote = None;
                } else if quote.is_none() {
                    quote = Some(ch);
                }
            }
            '[' if quote.is_none() => bracket_stack.push(index),
            ']' if quote.is_none() => {
                bracket_stack.pop()?;
            }
            _ => {}
        }
    }
    if quote.is_none() && bracket_stack.len() == 1 {
        bracket_stack.pop()
    } else {
        None
    }
}

pub(crate) fn dom_api_selector_list_uses_defined_pseudo_class(selector_text: &str) -> bool {
    let input = selector_text;
    let mut parser = Parser::new(input);
    selector_tokens_use_pseudo_class(&mut parser, "defined")
}

fn selector_tokens_use_pseudo_class(parser: &mut Parser<'_>, pseudo_class_name: &str) -> bool {
    let mut previous_was_colon = false;
    while let Ok(token) = parser.next_including_whitespace_and_comments().cloned() {
        match token {
            Token::Colon => {
                if previous_was_colon {
                    previous_was_colon = false;
                    continue;
                }
                previous_was_colon = true;
            }
            Token::Ident(name)
                if previous_was_colon && name.eq_ignore_ascii_case(pseudo_class_name) =>
            {
                return true;
            }
            Token::Function(_) | Token::ParenthesisBlock | Token::CurlyBracketBlock => {
                previous_was_colon = false;
                if parser
                    .parse_nested_block(|parser| {
                        selector_tokens_use_pseudo_class(parser, pseudo_class_name)
                            .then_some(())
                            .ok_or_else(|| cssparser::ParseError::<()>::custom(()))
                    })
                    .is_ok()
                {
                    return true;
                }
            }
            Token::SquareBracketBlock => {
                previous_was_colon = false;
                if consume_nested_component_value(parser, &token).is_err() {
                    return false;
                }
            }
            _ => {
                previous_was_colon = false;
            }
        }
    }
    false
}

pub(crate) fn dom_api_selector_list_has_only_known_pseudo_elements(selector_text: &str) -> bool {
    let input = selector_text;
    let mut parser = Parser::new(input);
    let mut saw_any_selector = false;
    let mut current_has_tokens = false;
    let mut current_ends_with_known_pseudo_element = false;

    while !parser.is_exhausted() {
        let Ok(token) = parser.next_including_whitespace_and_comments().cloned() else {
            return false;
        };
        match token {
            Token::WhiteSpace(_) | Token::Comment(_) => {}
            Token::Comma => {
                if !current_has_tokens || !current_ends_with_known_pseudo_element {
                    return false;
                }
                saw_any_selector = true;
                current_has_tokens = false;
                current_ends_with_known_pseudo_element = false;
            }
            Token::Colon => {
                current_has_tokens = true;
                current_ends_with_known_pseudo_element =
                    parse_known_pseudo_element_after_colon(&mut parser).is_some();
            }
            token => {
                if token.is_parse_error() {
                    return false;
                }
                current_has_tokens = true;
                current_ends_with_known_pseudo_element = false;
                if matches!(
                    token,
                    Token::Function(_)
                        | Token::ParenthesisBlock
                        | Token::SquareBracketBlock
                        | Token::CurlyBracketBlock
                ) && consume_nested_component_value(&mut parser, &token).is_err()
                {
                    return false;
                }
            }
        }
    }

    (saw_any_selector || current_has_tokens) && current_ends_with_known_pseudo_element
}

pub(crate) fn dom_api_selector_list_contains_known_pseudo_element(selector_text: &str) -> bool {
    let input = selector_text;
    let mut parser = Parser::new(input);

    while !parser.is_exhausted() {
        let Ok(token) = parser.next_including_whitespace_and_comments().cloned() else {
            return false;
        };
        match token {
            Token::Colon => {
                if parse_known_pseudo_element_after_colon(&mut parser).is_some() {
                    return true;
                }
            }
            token => {
                if token.is_parse_error() {
                    return false;
                }
                if matches!(
                    token,
                    Token::Function(_)
                        | Token::ParenthesisBlock
                        | Token::SquareBracketBlock
                        | Token::CurlyBracketBlock
                ) && consume_nested_component_value(&mut parser, &token).is_err()
                {
                    return false;
                }
            }
        }
    }

    false
}

pub(crate) fn selector_list_has_invalid_terminal_pseudo_element_chain(selector_text: &str) -> bool {
    let input = selector_text;
    let mut parser = Parser::new(input);
    let mut selector_has_terminal_pseudo_element = false;

    while !parser.is_exhausted() {
        let Ok(token) = parser.next_including_whitespace_and_comments().cloned() else {
            return false;
        };
        match token {
            Token::WhiteSpace(_) | Token::Comment(_) => {}
            Token::Comma => {
                selector_has_terminal_pseudo_element = false;
            }
            Token::Colon => {
                if let Some(kind) = parse_known_pseudo_element_after_colon(&mut parser) {
                    if selector_has_terminal_pseudo_element {
                        return true;
                    }
                    selector_has_terminal_pseudo_element = kind == KnownPseudoElementKind::Terminal;
                }
            }
            token => {
                if token.is_parse_error() {
                    return false;
                }
                if matches!(
                    token,
                    Token::Function(_)
                        | Token::ParenthesisBlock
                        | Token::SquareBracketBlock
                        | Token::CurlyBracketBlock
                ) && consume_nested_component_value(&mut parser, &token).is_err()
                {
                    return false;
                }
            }
        }
    }

    false
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum KnownPseudoElementKind {
    Terminal,
    Chainable,
}

fn parse_known_pseudo_element_after_colon(
    parser: &mut Parser<'_>,
) -> Option<KnownPseudoElementKind> {
    let state = parser.state();
    if !matches!(
        parser
            .next_including_whitespace_and_comments()
            .cloned()
            .ok()?,
        Token::Colon
    ) {
        parser.reset(&state);
    }
    let Ok(token) = parser.next_including_whitespace_and_comments().cloned() else {
        return None;
    };
    match token {
        Token::Ident(name) => {
            is_known_terminal_pseudo_element_name(&name).then_some(KnownPseudoElementKind::Terminal)
        }
        Token::Function(name) => {
            let kind = match name.to_ascii_lowercase().as_str() {
                "cue" | "highlight" => KnownPseudoElementKind::Terminal,
                "part" | "slotted" => KnownPseudoElementKind::Chainable,
                _ => return None,
            };
            let _ = consume_nested_component_value(parser, &Token::Function(name));
            Some(kind)
        }
        _ => None,
    }
}

fn is_known_terminal_pseudo_element_name(name: &str) -> bool {
    matches!(
        name.to_ascii_lowercase().as_str(),
        "after"
            | "backdrop"
            | "before"
            | "checkmark"
            | "cue"
            | "file-selector-button"
            | "first-letter"
            | "first-line"
            | "grammar-error"
            | "marker"
            | "picker-icon"
            | "placeholder"
            | "selection"
            | "spelling-error"
            | "target-text"
            | "view-transition"
    )
}

pub fn get_computed_style_pseudo_element(value: &str) -> GetComputedStylePseudoElement {
    let trimmed = value.trim_start();
    if !trimmed.starts_with(':') {
        return GetComputedStylePseudoElement::OriginatingElement;
    }
    let (double_colon, rest) = if let Some(rest) = trimmed.strip_prefix("::") {
        (true, rest)
    } else {
        (false, &trimmed[1..])
    };
    match parse_get_computed_style_pseudo_component(rest, double_colon) {
        Some(pseudo) => GetComputedStylePseudoElement::PseudoElement(pseudo),
        None => GetComputedStylePseudoElement::EmptyStyle,
    }
}

fn parse_get_computed_style_pseudo_component(value: &str, allow_modern: bool) -> Option<String> {
    let input = value;
    let mut parser = Parser::new(input);
    let token = parser
        .next_including_whitespace_and_comments()
        .ok()?
        .clone();
    let pseudo = match token {
        Token::Ident(name) => {
            let name = name.to_ascii_lowercase();
            if matches!(
                name.as_str(),
                "before" | "after" | "first-line" | "first-letter"
            ) || (allow_modern && is_known_terminal_pseudo_element_name(&name))
            {
                name
            } else {
                return None;
            }
        }
        Token::Function(name) if allow_modern => {
            let name = name.to_ascii_lowercase();
            let argument = parser
                .parse_nested_block(|nested| {
                    parse_functional_pseudo_element_argument(&name, nested)
                })
                .ok()?;
            format!("{name}({argument})")
        }
        _ => return None,
    };
    parser
        .next_including_whitespace_and_comments()
        .is_err()
        .then_some(pseudo)
}

fn parse_functional_pseudo_element_argument<'i>(
    name: &str,
    parser: &mut Parser<'i>,
) -> Result<String, cssparser::ParseError<()>> {
    let argument = match name {
        "highlight"
        | "view-transition-image-pair"
        | "view-transition-group"
        | "view-transition-old"
        | "view-transition-new" => {
            let ident = parser
                .expect_ident_cloned()
                .map_err(cssparser::ParseError::from)?;
            let ident = ident.to_string();
            if ident == "*" {
                return Err(cssparser::ParseError::custom(()));
            }
            ident
        }
        "picker" => {
            let ident = parser
                .expect_ident_cloned()
                .map_err(cssparser::ParseError::from)?;
            if !ident.eq_ignore_ascii_case("select") {
                return Err(cssparser::ParseError::custom(()));
            }
            "select".to_owned()
        }
        _ => return Err(cssparser::ParseError::custom(())),
    };
    if parser.is_exhausted() {
        Ok(argument)
    } else {
        Err(cssparser::ParseError::custom(()))
    }
}

fn consume_nested_component_value<'i>(
    input: &mut Parser<'i>,
    token: &Token<'i>,
) -> Result<(), cssparser::ParseError<()>> {
    if matches!(
        token,
        Token::Function(_)
            | Token::ParenthesisBlock
            | Token::SquareBracketBlock
            | Token::CurlyBracketBlock
    ) {
        input.parse_nested_block(consume_component_values)?;
    }
    Ok(())
}

fn consume_component_values<'i>(input: &mut Parser<'i>) -> Result<(), cssparser::ParseError<()>> {
    while !input.is_exhausted() {
        let token = input
            .next_including_whitespace_and_comments()
            .map_err(cssparser::ParseError::from)?
            .clone();
        if token.is_parse_error() {
            return Err(cssparser::BasicParseError::unexpected_token().into());
        }
        consume_nested_component_value(input, &token)?;
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_simple_attribute_selectors_with_cssparser_tokens() {
        assert_eq!(
            parse_css_attribute_selector("[data-x]").unwrap(),
            CssAttributeSelector {
                name: "data-x".to_owned(),
                operator: CssAttributeSelectorOperator::Exists,
                expected: None,
            }
        );
        assert_eq!(
            parse_css_attribute_selector(r#"[data-x~="foo"]"#).unwrap(),
            CssAttributeSelector {
                name: "data-x".to_owned(),
                operator: CssAttributeSelectorOperator::Includes,
                expected: Some("foo".to_owned()),
            }
        );
        assert_eq!(
            parse_css_attribute_selector("[data-x^='foo']")
                .unwrap()
                .operator,
            CssAttributeSelectorOperator::Prefix
        );
        assert_eq!(
            parse_css_attribute_selector(r#"[data-x*=""]"#).unwrap(),
            CssAttributeSelector {
                name: "data-x".to_owned(),
                operator: CssAttributeSelectorOperator::Substring,
                expected: Some(String::new()),
            }
        );
    }

    #[test]
    fn rejects_attribute_selectors_outside_cssom_serializer_subset() {
        assert!(parse_css_attribute_selector("[data-x=\"foo\" i]").is_none());
        assert!(parse_css_attribute_selector("[|data-x]").is_none());
        assert!(parse_css_attribute_selector("[data-x=foo bar]").is_none());
        assert!(parse_css_attribute_selector("data-x=foo").is_none());
    }

    #[test]
    fn detects_namespace_separators_with_css_tokens() {
        assert!(selector_list_has_namespace_separator("myhtml|div"));
        assert!(selector_list_has_namespace_separator("*|div"));
        assert!(selector_list_has_namespace_separator(r#"[ns\:odd|foo]"#));
        assert!(!selector_list_has_namespace_separator(r#"[data-x|="foo"]"#));
        assert!(!selector_list_has_namespace_separator(r#"[data-x="a|b"]"#));
    }

    #[test]
    fn collects_namespace_prefixes_with_css_tokens() {
        assert_eq!(
            selector_list_namespace_prefixes("svg|a, :not(math|mi), *|span, |div"),
            vec!["svg".to_owned(), "math".to_owned()]
        );
        assert!(selector_list_namespace_prefixes(r#"[data-x|="foo"]"#).is_empty());
    }

    #[test]
    fn serializes_cssom_selector_text_without_default_namespace() {
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("  #container ").unwrap(),
            "#container"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("span  div  ").unwrap(),
            "span div"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("*|div").unwrap(),
            "div"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("*|*").unwrap(),
            "*"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("[|lang]").unwrap(),
            "[lang]"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("[*|lang]").unwrap(),
            "[*|lang]"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("*:not(:active)").unwrap(),
            ":not(:active)"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":first-line").unwrap(),
            "::first-line"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace("[att=val]").unwrap(),
            r#"[att="val"]"#
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(r"[ns\:foo]").unwrap(),
            r"[ns\:foo]"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(r"[\30zonk]").unwrap(),
            r"[\30 zonk]"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(r"[\@]").unwrap(),
            r"[\@]"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(r#"[att~="val"]"#).unwrap(),
            r#"[att~="val"]"#
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":is(ul,ol,.list) > [hidden]")
                .unwrap(),
            ":is(ul, ol, .list) > [hidden]"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":where(:hover,:focus)")
                .unwrap(),
            ":where(:hover, :focus)"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":not([disabled],[selected])")
                .unwrap(),
            ":not([disabled], [selected])"
        );
    }

    #[test]
    fn parses_get_computed_style_pseudo_element_argument() {
        assert_eq!(
            get_computed_style_pseudo_element("before"),
            GetComputedStylePseudoElement::OriginatingElement
        );
        assert_eq!(
            get_computed_style_pseudo_element("file-selector-button"),
            GetComputedStylePseudoElement::OriginatingElement
        );
        assert_eq!(
            get_computed_style_pseudo_element(":before"),
            GetComputedStylePseudoElement::PseudoElement("before".to_owned())
        );
        assert_eq!(
            get_computed_style_pseudo_element(":checkmark"),
            GetComputedStylePseudoElement::EmptyStyle
        );
        assert_eq!(
            get_computed_style_pseudo_element("::checkmark"),
            GetComputedStylePseudoElement::PseudoElement("checkmark".to_owned())
        );
        assert_eq!(
            get_computed_style_pseudo_element("::highlight( n\\61me )"),
            GetComputedStylePseudoElement::PseudoElement("highlight(name)".to_owned())
        );
        assert_eq!(
            get_computed_style_pseudo_element("::picker(select)"),
            GetComputedStylePseudoElement::PseudoElement("picker(select)".to_owned())
        );
        assert_eq!(
            get_computed_style_pseudo_element("::picker(div)"),
            GetComputedStylePseudoElement::EmptyStyle
        );
        assert_eq!(
            get_computed_style_pseudo_element("::before(test)"),
            GetComputedStylePseudoElement::EmptyStyle
        );
    }

    #[test]
    fn serializes_cssom_nth_pseudo_class_arguments() {
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":nth-child(  3n - 0)")
                .unwrap(),
            ":nth-child(3n)"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":nth-child(even)").unwrap(),
            ":nth-child(2n)"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":nth-last-child(odd)")
                .unwrap(),
            ":nth-last-child(2n+1)"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":nth-of-type( -1n + 5 )")
                .unwrap(),
            ":nth-of-type(-n+5)"
        );
        assert_eq!(
            serialize_cssom_selector_text_without_default_namespace(":nth-last-of-type(+10)")
                .unwrap(),
            ":nth-last-of-type(10)"
        );
    }

    #[test]
    fn serializes_cssom_selector_text_with_default_namespace() {
        let prefixes = vec!["nsdefault".to_owned()];
        assert_eq!(
            serialize_cssom_selector_text("*|div", true, &prefixes).unwrap(),
            "*|div"
        );
        assert_eq!(
            serialize_cssom_selector_text("*|*.c", true, &prefixes).unwrap(),
            "*|*.c"
        );
        assert_eq!(
            serialize_cssom_selector_text("nsdefault|div", true, &prefixes).unwrap(),
            "div"
        );
        assert_eq!(
            serialize_cssom_selector_text("nsdefault|*.c", true, &prefixes).unwrap(),
            ".c"
        );
        assert_eq!(
            serialize_cssom_selector_text("svg|*.c", true, &prefixes).unwrap(),
            "svg|*.c"
        );
    }

    #[test]
    fn detects_known_terminal_pseudo_element_selectors_with_css_tokens() {
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "#target::before"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "#target:first-line, #other::after"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "#target::placeholder"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "#target::selection, #other::marker"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "#file::file-selector-button"
        ));
        assert!(!dom_api_selector_list_has_only_known_pseudo_elements(
            "#target::example"
        ));
        assert!(!dom_api_selector_list_has_only_known_pseudo_elements(
            "#target::before, .real"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "::slotted(foo)"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "::slotted(foo"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "#target::part(label)"
        ));
        assert!(dom_api_selector_list_has_only_known_pseudo_elements(
            "#target::highlight(foo)"
        ));
    }

    #[test]
    fn detects_known_pseudo_elements_with_following_pseudo_classes() {
        assert!(dom_api_selector_list_contains_known_pseudo_element(
            "::part(label):hover"
        ));
        assert!(dom_api_selector_list_contains_known_pseudo_element(
            "::part(label):lang(en)"
        ));
        assert!(dom_api_selector_list_contains_known_pseudo_element(
            "#target::before:hover"
        ));
        assert!(!dom_api_selector_list_has_only_known_pseudo_elements(
            "::part(label):hover"
        ));
        assert!(!dom_api_selector_list_contains_known_pseudo_element(
            ".real:hover"
        ));
    }

    #[test]
    fn detects_invalid_terminal_pseudo_element_chains() {
        assert!(selector_list_has_invalid_terminal_pseudo_element_chain(
            "::before::highlight(foo)"
        ));
        assert!(selector_list_has_invalid_terminal_pseudo_element_chain(
            "::highlight(foo)::after"
        ));
        assert!(selector_list_has_invalid_terminal_pseudo_element_chain(
            "::highlight(foo)::part(label)"
        ));
        assert!(!selector_list_has_invalid_terminal_pseudo_element_chain(
            "::part(label)::highlight(foo)"
        ));
        assert!(!selector_list_has_invalid_terminal_pseudo_element_chain(
            "#target::highlight(foo), #other::after"
        ));
    }

    #[test]
    fn detects_defined_pseudo_class_with_css_tokens() {
        assert!(dom_api_selector_list_uses_defined_pseudo_class(":defined"));
        assert!(dom_api_selector_list_uses_defined_pseudo_class(
            "wpt-defined-case:Defined"
        ));
        assert!(dom_api_selector_list_uses_defined_pseudo_class(
            ":is(:DEFINED)"
        ));
        assert!(dom_api_selector_list_uses_defined_pseudo_class(
            r#":\64 efined"#
        ));
        assert!(!dom_api_selector_list_uses_defined_pseudo_class(".defined"));
        assert!(!dom_api_selector_list_uses_defined_pseudo_class(
            "[data-x=':defined']"
        ));
        assert!(!dom_api_selector_list_uses_defined_pseudo_class(
            "div:definedish"
        ));
        assert!(!dom_api_selector_list_uses_defined_pseudo_class(
            "div::defined"
        ));
    }

    #[test]
    fn recovers_trailing_unclosed_attribute_selector_text() {
        assert_eq!(
            dom_api_selector_text_with_trailing_attribute_recovery(r#"#x [align="center""#),
            r#"#x [align="center"]"#
        );
        assert_eq!(
            dom_api_selector_text_with_trailing_attribute_recovery("#x [align]"),
            "#x [align]"
        );
        assert_eq!(
            dom_api_selector_text_with_trailing_attribute_recovery("[class=space unquoted]"),
            "[class=space unquoted]"
        );
    }
}