accent_sass_compiler 0.16.0

use std::{iter::Iterator, marker::PhantomData, sync::Arc};

use codemap::Spanned;

use crate::{
    ContextFlags, Token,
    ast::*,
    color::{Color, ColorFormat, NAMED_COLORS},
    common::{BinaryOp, Brackets, Identifier, ListSeparator, QuoteKind, UnaryOp, unvendor},
    error::SassResult,
    unit::Unit,
    utils::{as_hex, is_name_start, opposite_bracket},
    value::{CalculationName, Number},
};

use super::StylesheetParser;

pub(crate) type Predicate<'c, P> = &'c dyn Fn(&mut P) -> SassResult<bool>;

fn is_hex_color(interpolation: &Interpolation) -> bool {
    if let Some(plain) = interpolation.as_plain() {
        if ![3, 4, 6, 8].contains(&plain.len()) {
            return false;
        }

        return plain.chars().all(|c| c.is_ascii_hexdigit());
    }

    false
}

/// Where an operand of a calculation sits, which decides what a failure to
/// find one is called.
///
/// Dart Sass parses a calculation with its ordinary expression parser, so the
/// two positions fail differently and this reproduces that. Nothing is
/// committed at the start of an argument, and `calc(,)` reads as a malformed
/// function call -- `expected ")".`. An operator has promised an operand, so
/// `calc(1px *)` is a missing one -- `Expected expression.`. Both were taken
/// from dart-sass 1.103.1.
#[derive(Clone, Copy, Debug)]
pub(crate) enum OperandPosition {
    /// The first operand of a calculation argument.
    ArgumentStart,
    /// An operand an operator has already promised.
    AfterOperator,
}

impl OperandPosition {
    /// What to say when no operand is there.
    fn no_operand(self) -> &'static str {
        match self {
            Self::ArgumentStart => "expected \")\".",
            Self::AfterOperator => "Expected expression.",
        }
    }
}

pub(crate) struct ValueParser<'a, 'c, P: StylesheetParser<'a>> {
    comma_expressions: Option<Vec<Spanned<AstExpr>>>,
    space_expressions: Option<Vec<Spanned<AstExpr>>>,
    binary_operators: Option<Vec<BinaryOp>>,
    operands: Option<Vec<Spanned<AstExpr>>>,
    allow_slash: bool,
    single_expression: Option<Spanned<AstExpr>>,
    start: usize,
    inside_bracketed_list: bool,
    single_equals: bool,
    /// Whether a newline counts as whitespace inside this expression.
    ///
    /// Only the indented syntax cares; see
    /// [`BaseParser::whitespace_without_comments`].
    consume_newlines: bool,
    parse_until: Option<Predicate<'c, P>>,
    _a: PhantomData<&'a ()>,
}

/// Whether a condition contains a `sass()` expression at any depth.
fn condition_contains_sass(condition: &CssIfCondition) -> bool {
    match condition {
        CssIfCondition::Sass(..) => true,
        CssIfCondition::Else | CssIfCondition::Raw(..) => false,
        CssIfCondition::Paren(inner) | CssIfCondition::Not(inner) => condition_contains_sass(inner),
        CssIfCondition::And(operands) | CssIfCondition::Or(operands) => {
            operands.iter().any(condition_contains_sass)
        }
    }
}

/// One term of a CSS `if()` condition, before it is known whether the term
/// stands alone or is part of an opaque run.
enum CssIfAtom {
    Sass(AstExpr),
    Paren(CssIfCondition),
    Raw(Interpolation),
}

/// The calculation-only constants, matched case-insensitively.
///
/// They are ordinary identifiers outside a calculation, so this lookup only
/// ever runs from [`ValueParser::parse_calculation_identifier`]. Note that only
/// `infinity` has a negated spelling; `-pi` and `-e` stay identifiers.
fn calculation_constant_value(lowercase: &str) -> Option<f64> {
    Some(match lowercase {
        "pi" => std::f64::consts::PI,
        "e" => std::f64::consts::E,
        "infinity" => f64::INFINITY,
        "-infinity" => f64::NEG_INFINITY,
        "nan" => f64::NAN,
        _ => return None,
    })
}

impl<'a, 'c, P: StylesheetParser<'a>> ValueParser<'a, 'c, P> {
    pub fn parse_expression(
        parser: &mut P,
        parse_until: Option<Predicate<'c, P>>,
        consume_newlines: bool,
        inside_bracketed_list: bool,
        single_equals: bool,
    ) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        let mut value_parser = Self::new(
            parser,
            parse_until,
            consume_newlines,
            inside_bracketed_list,
            single_equals,
        );

        if let Some(parse_until) = value_parser.parse_until
            && parse_until(parser)?
        {
            return Err(("Expected expression.", parser.toks().current_span()).into());
        }

        if value_parser.inside_bracketed_list {
            let bracket_start = parser.toks().cursor();

            parser.expect_char('[')?;
            parser.whitespace(true)?;

            if parser.scan_char(']') {
                return Ok(AstExpr::List(ListExpr {
                    elems: Vec::new(),
                    separator: ListSeparator::Undecided,
                    brackets: Brackets::Bracketed,
                })
                .span(parser.toks_mut().span_from(bracket_start)));
            }
        };

        // From here on the parser is inside an expression, which plain CSS cares
        // about: `//` in a value is two slashes, not a silent comment.
        let was_in_expression = parser.flags().in_expression();
        parser.flags_mut().set(ContextFlags::IN_EXPRESSION, true);

        let value = value_parser.parse_expression_body(parser, start);

        parser
            .flags_mut()
            .set(ContextFlags::IN_EXPRESSION, was_in_expression);

        value
    }

    /// Parses the expression itself, once [`ValueParser::parse_expression`] has
    /// dealt with the bracketed-list prefix.
    ///
    /// `start` is the cursor from before that prefix, so the span covers it.
    fn parse_expression_body(
        &mut self,
        parser: &mut P,
        start: usize,
    ) -> SassResult<Spanned<AstExpr>> {
        self.start = parser.toks().cursor();

        self.single_expression = Some(self.parse_single_expression(parser)?);

        let mut value = self.parse_value(parser)?;
        value.span = parser.toks_mut().span_from(start);

        Ok(value)
    }

    pub fn new(
        parser: &mut P,
        parse_until: Option<Predicate<'c, P>>,
        consume_newlines: bool,
        inside_bracketed_list: bool,
        single_equals: bool,
    ) -> Self {
        Self {
            comma_expressions: None,
            space_expressions: None,
            binary_operators: None,
            operands: None,
            allow_slash: true,
            start: parser.toks().cursor(),
            single_expression: None,
            parse_until,
            consume_newlines,
            inside_bracketed_list,
            single_equals,
            _a: PhantomData,
        }
    }

    /// Parse a value from a stream of tokens
    ///
    /// This function will cease parsing if the predicate returns true.
    pub(crate) fn parse_value(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        // A bracketed list is inside brackets, so a newline is whitespace there
        // whatever the caller asked for.
        let consume_newlines = self.consume_newlines || self.inside_bracketed_list;

        parser.whitespace(consume_newlines)?;

        let start = parser.toks().cursor();

        let was_in_parens = parser.flags().in_parens();

        loop {
            parser.whitespace(consume_newlines)?;

            if let Some(parse_until) = self.parse_until
                && parse_until(parser)?
            {
                break;
            }

            let first = parser.toks().peek();

            match first {
                Some(Token { kind: '(', .. }) => {
                    let expr = self.parse_paren_expr(parser)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: '[', .. }) => {
                    let expr = parser.parse_expression(None, false, Some(true), None)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: '$', .. }) => {
                    let expr = Self::parse_variable(parser)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: '&', .. }) => {
                    let expr = Self::parse_selector(parser)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: '"', .. }) | Some(Token { kind: '\'', .. }) => {
                    let expr = parser
                        .parse_interpolated_string()?
                        .map_node(|s| AstExpr::String(s, parser.toks_mut().span_from(start)));
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: '#', .. }) => {
                    let expr = self.parse_hash(parser)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: '=', .. }) => {
                    parser.toks_mut().next();
                    if self.single_equals
                        && !matches!(parser.toks().peek(), Some(Token { kind: '=', .. }))
                    {
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::SingleEq,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    } else {
                        parser.expect_char('=')?;
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::Equal,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    }
                }
                Some(Token { kind: '!', .. }) => match parser.toks().peek_n(1) {
                    Some(Token { kind: '=', .. }) => {
                        parser.toks_mut().next();
                        parser.toks_mut().next();
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::NotEqual,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    }
                    Some(Token { kind, .. })
                        if kind.is_ascii_whitespace() || kind == 'i' || kind == 'I' =>
                    {
                        let expr = Self::parse_important_expr(parser)?;
                        self.add_single_expression(expr, parser)?;
                    }
                    None => {
                        let expr = Self::parse_important_expr(parser)?;
                        self.add_single_expression(expr, parser)?;
                    }
                    Some(..) => break,
                },
                Some(Token { kind: '<', .. }) => {
                    parser.toks_mut().next();
                    self.add_operator(
                        Spanned {
                            node: if parser.scan_char('=') {
                                BinaryOp::LessThanEqual
                            } else {
                                BinaryOp::LessThan
                            },
                            span: parser.toks_mut().span_from(start),
                        },
                        parser,
                    )?;
                }
                Some(Token { kind: '>', .. }) => {
                    parser.toks_mut().next();
                    self.add_operator(
                        Spanned {
                            node: if parser.scan_char('=') {
                                BinaryOp::GreaterThanEqual
                            } else {
                                BinaryOp::GreaterThan
                            },
                            span: parser.toks_mut().span_from(start),
                        },
                        parser,
                    )?;
                }
                Some(Token { kind: '*', .. }) => {
                    parser.toks_mut().next();
                    self.add_operator(
                        Spanned {
                            node: BinaryOp::Mul,
                            span: parser.toks().current_span(),
                        },
                        parser,
                    )?;
                }
                Some(Token { kind: '+', .. }) => {
                    if self.single_expression.is_none() {
                        let expr = self.parse_unary_operation(parser)?;
                        self.add_single_expression(expr, parser)?;
                    } else {
                        parser.toks_mut().next();
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::Plus,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    }
                }
                Some(Token { kind: '-', .. }) => {
                    if matches!(
                        parser.toks().peek_n(1),
                        Some(Token {
                            kind: '0'..='9' | '.',
                            ..
                        })
                    ) && (self.single_expression.is_none()
                        || matches!(
                            parser.toks_mut().peek_previous(),
                            Some(Token {
                                kind: ' ' | '\t' | '\n' | '\r',
                                ..
                            })
                        ))
                    {
                        let expr = ValueParser::parse_number(parser)?;
                        self.add_single_expression(expr, parser)?;
                    } else if parser.looking_at_interpolated_identifier() {
                        let expr = self.parse_identifier_like(parser)?;
                        self.add_single_expression(expr, parser)?;
                    } else if self.single_expression.is_none() {
                        let expr = self.parse_unary_operation(parser)?;
                        self.add_single_expression(expr, parser)?;
                    } else {
                        parser.toks_mut().next();
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::Minus,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    }
                }
                Some(Token { kind: '/', .. }) => {
                    if self.single_expression.is_none() {
                        let expr = self.parse_unary_operation(parser)?;
                        self.add_single_expression(expr, parser)?;
                    } else {
                        parser.toks_mut().next();
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::Div,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    }
                }
                Some(Token { kind: '%', .. }) => {
                    if self.percent_is_value(parser) {
                        let expr = Self::parse_percent_value(parser)?;
                        // A `%` value ends any slash-separated list being
                        // built, the way `add_operator` would for a real
                        // operator: `1/2 %` is division, not `1/2` kept as a
                        // slash list.
                        self.allow_slash = false;
                        self.add_single_expression(expr, parser)?;
                    } else {
                        parser.toks_mut().next();
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::Rem,
                                span: parser.toks().current_span(),
                            },
                            parser,
                        )?;
                    }
                }
                Some(Token {
                    kind: '0'..='9', ..
                }) => {
                    let expr = ValueParser::parse_number(parser)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: '.', .. }) => {
                    if matches!(parser.toks().peek_n(1), Some(Token { kind: '.', .. })) {
                        break;
                    }
                    let expr = ValueParser::parse_number(parser)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: 'a', .. }) => {
                    if !parser.is_plain_css() && parser.scan_identifier("and", false)? {
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::And,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    } else {
                        let expr = self.parse_identifier_like(parser)?;
                        self.add_single_expression(expr, parser)?;
                    }
                }
                Some(Token { kind: 'o', .. }) => {
                    if !parser.is_plain_css() && parser.scan_identifier("or", false)? {
                        self.add_operator(
                            Spanned {
                                node: BinaryOp::Or,
                                span: parser.toks_mut().span_from(start),
                            },
                            parser,
                        )?;
                    } else {
                        let expr = self.parse_identifier_like(parser)?;
                        self.add_single_expression(expr, parser)?;
                    }
                }
                Some(Token { kind: 'u', .. }) | Some(Token { kind: 'U', .. }) => {
                    if matches!(parser.toks().peek_n(1), Some(Token { kind: '+', .. })) {
                        let expr = Self::parse_unicode_range(parser)?;
                        self.add_single_expression(expr, parser)?;
                    } else {
                        let expr = self.parse_identifier_like(parser)?;
                        self.add_single_expression(expr, parser)?;
                    }
                }
                Some(Token {
                    kind: 'b'..='z', ..
                })
                | Some(Token {
                    kind: 'A'..='Z', ..
                })
                | Some(Token { kind: '_', .. })
                | Some(Token { kind: '\\', .. })
                | Some(Token {
                    kind: '\u{80}'..=std::char::MAX,
                    ..
                }) => {
                    let expr = self.parse_identifier_like(parser)?;
                    self.add_single_expression(expr, parser)?;
                }
                Some(Token { kind: ',', .. }) => {
                    // If we discover we're parsing a list whose first element is a
                    // division operation, and we're in parentheses, reparse outside of a
                    // paren context. This ensures that `(1/2, 1)` doesn't perform division
                    // on its first element.
                    if parser.flags().in_parens() {
                        parser.flags_mut().set(ContextFlags::IN_PARENS, false);
                        if self.allow_slash {
                            self.reset_state(parser)?;
                            continue;
                        }
                        // todo: does this branch ever get hit
                    }

                    if self.single_expression.is_none() {
                        return Err(("Expected expression.", parser.toks().current_span()).into());
                    }

                    self.resolve_space_expressions(parser)?;

                    // [resolveSpaceExpressions] can modify [singleExpression_], but it
                    // can't set it to null`.
                    self.comma_expressions
                        .get_or_insert_with(Default::default)
                        .push(self.single_expression.take().unwrap());
                    parser.toks_mut().next();
                    self.allow_slash = true;
                }
                Some(..) | None => break,
            }
        }

        if self.inside_bracketed_list {
            parser.expect_char(']')?;
        }

        if self.comma_expressions.is_some() {
            self.resolve_space_expressions(parser)?;

            parser
                .flags_mut()
                .set(ContextFlags::IN_PARENS, was_in_parens);

            if let Some(single_expression) = self.single_expression.take() {
                self.comma_expressions
                    .as_mut()
                    .unwrap()
                    .push(single_expression);
            }

            Ok(AstExpr::List(ListExpr {
                elems: self.comma_expressions.take().unwrap(),
                separator: ListSeparator::Comma,
                brackets: if self.inside_bracketed_list {
                    Brackets::Bracketed
                } else {
                    Brackets::None
                },
            })
            .span(parser.toks_mut().span_from(start)))
        } else if self.inside_bracketed_list && self.space_expressions.is_some() {
            self.resolve_operations(parser)?;

            self.space_expressions
                .as_mut()
                .unwrap()
                .push(self.single_expression.take().unwrap());

            Ok(AstExpr::List(ListExpr {
                elems: self.space_expressions.take().unwrap(),
                separator: ListSeparator::Space,
                brackets: Brackets::Bracketed,
            })
            .span(parser.toks_mut().span_from(start)))
        } else {
            self.resolve_space_expressions(parser)?;

            if self.inside_bracketed_list {
                return Ok(AstExpr::List(ListExpr {
                    elems: vec![self.single_expression.take().unwrap()],
                    separator: ListSeparator::Undecided,
                    brackets: Brackets::Bracketed,
                })
                .span(parser.toks_mut().span_from(start)));
            }

            Ok(self.single_expression.take().unwrap())
        }
    }

    fn parse_single_expression(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        let first = parser.toks().peek();

        match first {
            Some(Token { kind: '(', .. }) => self.parse_paren_expr(parser),
            Some(Token { kind: '/', .. }) => self.parse_unary_operation(parser),
            Some(Token { kind: '[', .. }) => {
                Self::parse_expression(parser, None, false, true, false)
            }
            Some(Token { kind: '$', .. }) => Self::parse_variable(parser),
            Some(Token { kind: '&', .. }) => Self::parse_selector(parser),
            Some(Token { kind: '"', .. }) | Some(Token { kind: '\'', .. }) => Ok(parser
                .parse_interpolated_string()?
                .map_node(|s| AstExpr::String(s, parser.toks_mut().span_from(start)))),
            Some(Token { kind: '#', .. }) => self.parse_hash(parser),
            Some(Token { kind: '%', .. }) => Self::parse_percent_value(parser),
            Some(Token { kind: '+', .. }) => self.parse_plus_expr(parser),
            Some(Token { kind: '-', .. }) => self.parse_minus_expr(parser),
            Some(Token { kind: '!', .. }) => Self::parse_important_expr(parser),
            Some(Token { kind: 'u', .. }) | Some(Token { kind: 'U', .. }) => {
                if matches!(parser.toks().peek_n(1), Some(Token { kind: '+', .. })) {
                    Self::parse_unicode_range(parser)
                } else {
                    self.parse_identifier_like(parser)
                }
            }
            Some(Token {
                kind: '0'..='9', ..
            })
            | Some(Token { kind: '.', .. }) => ValueParser::parse_number(parser),
            Some(Token {
                kind: 'a'..='z', ..
            })
            | Some(Token {
                kind: 'A'..='Z', ..
            })
            | Some(Token { kind: '_', .. })
            | Some(Token { kind: '\\', .. })
            | Some(Token {
                kind: '\u{80}'..=std::char::MAX,
                ..
            }) => self.parse_identifier_like(parser),
            // An empty span where the expression should start, as dart-sass's
            // `scanner.error` gives, rather than one reaching back over what
            // came before it.
            Some(..) | None => Err((
                "Expected expression.",
                parser.toks().current_span().subspan(0, 0),
            )
                .into()),
        }
    }

    fn resolve_one_operation(&mut self, parser: &mut P) -> SassResult<()> {
        let operator = self.binary_operators.as_mut().unwrap().pop().unwrap();
        let operands = self.operands.as_mut().unwrap();

        let left = operands.pop().unwrap();
        let right = match self.single_expression.take() {
            Some(val) => val,
            None => return Err(("Expected expression.", left.span).into()),
        };

        let span = left.span.merge(right.span);

        if self.allow_slash
            && !parser.flags().in_parens()
            && operator == BinaryOp::Div
            && left.node.is_slash_operand()
            && right.node.is_slash_operand()
        {
            self.single_expression = Some(AstExpr::slash(left.node, right.node, span).span(span));
        } else {
            self.single_expression = Some(
                AstExpr::BinaryOp(Arc::new(BinaryOpExpr {
                    lhs: left.node,
                    op: operator,
                    rhs: right.node,
                    allows_slash: false,
                    span,
                }))
                .span(span),
            );
            self.allow_slash = false;
        }

        Ok(())
    }

    fn resolve_operations(&mut self, parser: &mut P) -> SassResult<()> {
        loop {
            let should_break = match self.binary_operators.as_ref() {
                Some(bin) => bin.is_empty(),
                None => true,
            };

            if should_break {
                break;
            }

            self.resolve_one_operation(parser)?;
        }

        Ok(())
    }

    fn add_single_expression(
        &mut self,
        expression: Spanned<AstExpr>,
        parser: &mut P,
    ) -> SassResult<()> {
        if self.single_expression.is_some() {
            // If we discover we're parsing a list whose first element is a division
            // operation, and we're in parentheses, reparse outside of a paren
            // context. This ensures that `(1/2 1)` doesn't perform division on its
            // first element.
            if parser.flags().in_parens() {
                parser.flags_mut().set(ContextFlags::IN_PARENS, false);

                if self.allow_slash {
                    self.reset_state(parser)?;

                    return Ok(());
                }
            }

            if self.space_expressions.is_none() {
                self.space_expressions = Some(Vec::new());
            }

            self.resolve_operations(parser)?;

            self.space_expressions
                .as_mut()
                .unwrap()
                .push(self.single_expression.take().unwrap());

            self.allow_slash = true;
        }

        self.single_expression = Some(expression);

        Ok(())
    }

    fn add_operator(&mut self, op: Spanned<BinaryOp>, parser: &mut P) -> SassResult<()> {
        if parser.is_plain_css() && op.node != BinaryOp::Div && op.node != BinaryOp::SingleEq {
            return Err(("Operators aren't allowed in plain CSS.", op.span).into());
        }

        self.allow_slash = self.allow_slash && op.node == BinaryOp::Div;

        if self.binary_operators.is_none() {
            self.binary_operators = Some(Vec::new());
        }

        if self.operands.is_none() {
            self.operands = Some(Vec::new());
        }

        while let Some(last_op) = self.binary_operators.as_ref().unwrap_or(&Vec::new()).last() {
            if last_op.precedence() < op.precedence() {
                break;
            }

            self.resolve_one_operation(parser)?;
        }
        self.binary_operators
            .get_or_insert_with(Default::default)
            .push(op.node);

        match self.single_expression.take() {
            Some(expr) => {
                self.operands.get_or_insert_with(Vec::new).push(expr);
            }
            None => return Err(("Expected expression.", op.span).into()),
        }

        parser.whitespace(true)?;

        self.single_expression = Some(self.parse_single_expression(parser)?);

        Ok(())
    }

    fn resolve_space_expressions(&mut self, parser: &mut P) -> SassResult<()> {
        self.resolve_operations(parser)?;

        if let Some(mut space_expressions) = self.space_expressions.take() {
            let single_expression = match self.single_expression.take() {
                Some(val) => val,
                None => return Err(("Expected expression.", parser.toks().current_span()).into()),
            };

            let span = single_expression.span;

            space_expressions.push(single_expression);

            self.single_expression = Some(
                AstExpr::List(ListExpr {
                    elems: space_expressions,
                    separator: ListSeparator::Space,
                    brackets: Brackets::None,
                })
                .span(span),
            );
        }

        Ok(())
    }

    fn parse_map(
        parser: &mut P,
        first: Spanned<AstExpr>,
        start: usize,
    ) -> SassResult<Spanned<AstExpr>> {
        let mut pairs = vec![(first, parser.parse_expression_until_comma(false)?.node)];

        while parser.scan_char(',') {
            parser.whitespace(true)?;
            if !parser.looking_at_expression() {
                break;
            }

            let key = parser.parse_expression_until_comma(false)?;
            parser.expect_char(':')?;
            parser.whitespace(true)?;
            let value = parser.parse_expression_until_comma(false)?;
            pairs.push((key, value.node));
        }

        parser.expect_char(')')?;

        Ok(AstExpr::Map(AstSassMap(pairs)).span(parser.toks_mut().span_from(start)))
    }

    fn parse_paren_expr(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        if parser.is_plain_css() {
            return Err((
                "Parentheses aren't allowed in plain CSS.",
                parser.toks().current_span(),
            )
                .into());
        }

        let was_in_parentheses = parser.flags().in_parens();
        parser.flags_mut().set(ContextFlags::IN_PARENS, true);

        parser.expect_char('(')?;
        parser.whitespace(true)?;
        if !parser.looking_at_expression() {
            parser.expect_char(')')?;
            parser
                .flags_mut()
                .set(ContextFlags::IN_PARENS, was_in_parentheses);
            return Ok(AstExpr::List(ListExpr {
                elems: Vec::new(),
                separator: ListSeparator::Undecided,
                brackets: Brackets::None,
            })
            .span(parser.toks_mut().span_from(start)));
        }

        let first = parser.parse_expression_until_comma(false)?;
        if parser.scan_char(':') {
            parser.whitespace(true)?;
            parser
                .flags_mut()
                .set(ContextFlags::IN_PARENS, was_in_parentheses);
            return Self::parse_map(parser, first, start);
        }

        if !parser.scan_char(',') {
            parser.expect_char(')')?;
            parser
                .flags_mut()
                .set(ContextFlags::IN_PARENS, was_in_parentheses);
            return Ok(AstExpr::Paren(Arc::new(first.node)).span(first.span));
        }

        parser.whitespace(true)?;

        let mut expressions = vec![first];

        loop {
            if !parser.looking_at_expression() {
                break;
            }
            expressions.push(parser.parse_expression_until_comma(false)?);
            if !parser.scan_char(',') {
                break;
            }
            parser.whitespace(true)?;
        }

        parser.expect_char(')')?;

        parser
            .flags_mut()
            .set(ContextFlags::IN_PARENS, was_in_parentheses);

        Ok(AstExpr::List(ListExpr {
            elems: expressions,
            separator: ListSeparator::Comma,
            brackets: Brackets::None,
        })
        .span(parser.toks_mut().span_from(start)))
    }

    fn parse_variable(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        let name = parser.parse_variable_name()?;

        if parser.is_plain_css() {
            return Err((
                "Sass variables aren't allowed in plain CSS.",
                parser.toks_mut().span_from(start),
            )
                .into());
        }

        Ok(AstExpr::Variable {
            name: Spanned {
                node: Identifier::from(name),
                span: parser.toks_mut().span_from(start),
            },
            namespace: None,
        }
        .span(parser.toks_mut().span_from(start)))
    }

    fn parse_selector(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        if parser.is_plain_css() {
            return Err((
                "The parent selector isn't allowed in plain CSS.",
                parser.toks().current_span(),
            )
                .into());
        }

        let start = parser.toks().cursor();

        parser.expect_char('&')?;

        if parser.toks().next_char_is('&') {
            // todo: emit a warning here
            //   warn(
            //       'In Sass, "&&" means two copies of the parent selector. You '
            //       'probably want to use "and" instead.',
            //       scanner.spanFrom(start));
            //   scanner.position--;
        }

        Ok(AstExpr::ParentSelector.span(parser.toks_mut().span_from(start)))
    }

    fn parse_hash(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        debug_assert!(matches!(
            parser.toks().peek(),
            Some(Token { kind: '#', .. })
        ));

        if matches!(parser.toks().peek_n(1), Some(Token { kind: '{', .. })) {
            return self.parse_identifier_like(parser);
        }

        parser.expect_char('#')?;

        if matches!(
            parser.toks().peek(),
            Some(Token {
                kind: '0'..='9',
                ..
            })
        ) {
            let color = self.parse_hex_color_contents(parser)?;
            return Ok(AstExpr::Color(Arc::new(color)).span(parser.toks_mut().span_from(start)));
        }

        let after_hash = parser.toks().cursor();
        let ident = parser.parse_interpolated_identifier()?;
        if is_hex_color(&ident) {
            parser.toks_mut().set_cursor(after_hash);
            let color = self.parse_hex_color_contents(parser)?;
            return Ok(
                AstExpr::Color(Arc::new(color)).span(parser.toks_mut().span_from(after_hash))
            );
        }

        let mut buffer = Interpolation::new();

        buffer.add_char('#');
        buffer.add_interpolation(ident);

        let span = parser.toks_mut().span_from(start);

        Ok(AstExpr::String(StringExpr(buffer, QuoteKind::None), span).span(span))
    }

    fn parse_hex_digit(&mut self, parser: &mut P) -> SassResult<u32> {
        match parser.toks().peek() {
            Some(Token { kind, .. }) if kind.is_ascii_hexdigit() => {
                parser.toks_mut().next();
                Ok(as_hex(kind))
            }
            _ => Err(("Expected hex digit.", parser.toks().current_span()).into()),
        }
    }

    fn parse_hex_color_contents(&mut self, parser: &mut P) -> SassResult<Color> {
        let start = parser.toks().cursor();

        let digit1 = self.parse_hex_digit(parser)?;
        let digit2 = self.parse_hex_digit(parser)?;
        let digit3 = self.parse_hex_digit(parser)?;

        let red: u32;
        let green: u32;
        let blue: u32;
        // `None` records that no alpha channel was written, which is what
        // decides the serialization below. The alpha's *value* does not: an
        // opaque `#abcf` still loses its spelling.
        let mut alpha: Option<f64> = None;

        if parser.next_is_hex() {
            let digit4 = self.parse_hex_digit(parser)?;

            if parser.next_is_hex() {
                red = (digit1 << 4) + digit2;
                green = (digit3 << 4) + digit4;
                blue = (self.parse_hex_digit(parser)? << 4) + self.parse_hex_digit(parser)?;

                if parser.next_is_hex() {
                    alpha = Some(
                        ((self.parse_hex_digit(parser)? << 4) + self.parse_hex_digit(parser)?)
                            as f64
                            / 0xff as f64,
                    );
                }
            } else {
                // #abcd
                red = (digit1 << 4) + digit1;
                green = (digit2 << 4) + digit2;
                blue = (digit3 << 4) + digit3;
                alpha = Some(((digit4 << 4) + digit4) as f64 / 0xff as f64);
            }
        } else {
            // #abc
            red = (digit1 << 4) + digit1;
            green = (digit2 << 4) + digit2;
            blue = (digit3 << 4) + digit3;
        }

        // Don't emit four- or eight-digit hex colors as hex, since that's not
        // yet well-supported in browsers. dart-sass keeps the source spelling
        // only for the three- and six-digit forms; the rest fall back to
        // whatever the serializer infers, which is `rgba()` for a color with
        // an alpha channel.
        let format = if alpha.is_none() {
            ColorFormat::Literal(parser.toks_mut().raw_text(start - 1))
        } else {
            ColorFormat::Infer
        };

        Ok(Color::new_rgba(
            Number::from(red),
            Number::from(green),
            Number::from(blue),
            Number(alpha.unwrap_or(1.0)),
            format,
        ))
    }

    fn parse_unary_operation(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let op_span = parser.toks().current_span();
        let operator = Self::expect_unary_operator(parser)?;

        if parser.is_plain_css() && operator != UnaryOp::Div {
            return Err(("Operators aren't allowed in plain CSS.", op_span).into());
        }

        parser.whitespace(true)?;

        let operand = self.parse_single_expression(parser)?;

        let span = op_span.merge(parser.toks().current_span());

        Ok(AstExpr::UnaryOp(operator, Arc::new(operand.node), span).span(span))
    }

    fn expect_unary_operator(parser: &mut P) -> SassResult<UnaryOp> {
        let span = parser.toks().current_span();
        Ok(match parser.toks_mut().next() {
            Some(Token { kind: '+', .. }) => UnaryOp::Plus,
            Some(Token { kind: '-', .. }) => UnaryOp::Neg,
            Some(Token { kind: '/', .. }) => UnaryOp::Div,
            Some(..) | None => return Err(("Expected unary operator.", span).into()),
        })
    }

    fn consume_natural_number(parser: &mut P) -> SassResult<()> {
        if !matches!(
            parser.toks_mut().next(),
            Some(Token {
                kind: '0'..='9',
                ..
            })
        ) {
            return Err(("Expected digit.", parser.toks().prev_span()).into());
        }

        while matches!(
            parser.toks().peek(),
            Some(Token {
                kind: '0'..='9',
                ..
            })
        ) {
            parser.toks_mut().next();
        }

        Ok(())
    }

    fn parse_number(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();

        if !parser.scan_char('+') {
            parser.scan_char('-');
        }

        let after_sign = parser.toks().cursor();

        if !parser.toks().next_char_is('.') {
            ValueParser::consume_natural_number(parser)?;
        }

        ValueParser::try_decimal(parser, parser.toks().cursor() != after_sign)?;
        ValueParser::try_exponent(parser)?;

        let number: f64 = parser.toks_mut().raw_text(start).parse().unwrap();

        let unit = if parser.scan_char('%') {
            Unit::Percent
        } else if parser.looking_at_identifier()
            && (!matches!(parser.toks().peek(), Some(Token { kind: '-', .. }))
                || !matches!(parser.toks().peek_n(1), Some(Token { kind: '-', .. })))
        {
            Unit::from(parser.parse_identifier(false, true)?)
        } else {
            Unit::None
        };

        Ok(AstExpr::Number {
            n: Number::from(number),
            unit,
        }
        .span(parser.toks_mut().span_from(start)))
    }

    fn try_decimal(parser: &mut P, allow_trailing_dot: bool) -> SassResult<Option<String>> {
        if !matches!(parser.toks().peek(), Some(Token { kind: '.', .. })) {
            return Ok(None);
        }

        match parser.toks().peek_n(1) {
            Some(Token { kind, .. }) if !kind.is_ascii_digit() => {
                if allow_trailing_dot {
                    return Ok(None);
                }

                return Err(("Expected digit.", parser.toks().current_span()).into());
            }
            Some(..) => {}
            None => return Err(("Expected digit.", parser.toks().current_span()).into()),
        }

        let mut buffer = String::new();

        parser.expect_char('.')?;
        buffer.push('.');

        while let Some(Token { kind, .. }) = parser.toks().peek() {
            if !kind.is_ascii_digit() {
                break;
            }
            buffer.push(kind);
            parser.toks_mut().next();
        }

        Ok(Some(buffer))
    }

    fn try_exponent(parser: &mut P) -> SassResult<Option<String>> {
        let mut buffer = String::new();

        match parser.toks().peek() {
            Some(Token {
                kind: 'e' | 'E', ..
            }) => buffer.push('e'),
            _ => return Ok(None),
        }

        let next = match parser.toks().peek_n(1) {
            Some(Token {
                kind: kind @ ('0'..='9' | '-' | '+'),
                ..
            }) => kind,
            _ => return Ok(None),
        };

        parser.toks_mut().next();

        if next == '+' || next == '-' {
            parser.toks_mut().next();
            buffer.push(next);
        }

        match parser.toks().peek() {
            Some(Token {
                kind: '0'..='9', ..
            }) => {}
            _ => return Err(("Expected digit.", parser.toks().current_span()).into()),
        }

        while let Some(tok) = parser.toks().peek() {
            if !tok.kind.is_ascii_digit() {
                break;
            }

            buffer.push(tok.kind);

            parser.toks_mut().next();
        }

        Ok(Some(buffer))
    }

    fn parse_plus_expr(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        debug_assert!(parser.toks().next_char_is('+'));

        match parser.toks().peek_n(1) {
            Some(Token {
                kind: '0'..='9' | '.',
                ..
            }) => ValueParser::parse_number(parser),
            _ => self.parse_unary_operation(parser),
        }
    }

    fn parse_minus_expr(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        debug_assert!(parser.toks().next_char_is('-'));

        if matches!(
            parser.toks().peek_n(1),
            Some(Token {
                kind: '0'..='9' | '.',
                ..
            })
        ) {
            return ValueParser::parse_number(parser);
        }

        if parser.looking_at_interpolated_identifier() {
            return self.parse_identifier_like(parser);
        }

        self.parse_unary_operation(parser)
    }

    /// Decides whether a `%` at the cursor is a value rather than the modulo
    /// operator.
    ///
    /// dart-sass accepts a lone `%` as an unquoted string, so `a {b: %}` and
    /// `a {b: c %}` are both valid, but it still reads `5 % 2` as modulo. Two
    /// conditions separate them:
    ///
    /// - The `%` is the operator only when an operand follows it. A `%` with
    ///   nothing after it but the end of the value joins the space-separated
    ///   list instead, which is what makes `c %` and `1 %` parse.
    /// - A `%` value is only accepted before this expression has consumed a
    ///   comma. dart-sass rejects `1, %, 2` while accepting `%, 2`, and takes
    ///   `(1, %)` because parentheses parse each element as its own
    ///   expression. Both were verified against dart-sass 1.103.1.
    fn percent_is_value(&self, parser: &mut P) -> bool {
        if self.comma_expressions.is_some() {
            return false;
        }

        if self.single_expression.is_none() {
            return true;
        }

        // In plain CSS an operator is an error, so a `%` after an expression
        // has to stay one and be reported. dart-sass still takes a `%` in
        // single-expression position there, which the check above allows.
        if parser.is_plain_css() {
            return false;
        }

        !Self::expression_follows_percent(parser)
    }

    /// Reports whether an operand follows the `%` at the cursor, skipping the
    /// whitespace and comments that may separate them.
    fn expression_follows_percent(parser: &mut P) -> bool {
        let mut offset = 1;

        loop {
            match parser.toks().peek_n(offset) {
                Some(Token { kind, .. }) if kind.is_ascii_whitespace() => offset += 1,
                Some(Token { kind: '/', .. }) => match parser.toks().peek_n(offset + 1) {
                    Some(Token { kind: '*', .. }) => {
                        offset += 2;
                        loop {
                            match parser.toks().peek_n(offset) {
                                // An unterminated comment is a later error,
                                // not this predicate's to report.
                                None => return false,
                                Some(Token { kind: '*', .. })
                                    if matches!(
                                        parser.toks().peek_n(offset + 1),
                                        Some(Token { kind: '/', .. })
                                    ) =>
                                {
                                    offset += 2;
                                    break;
                                }
                                Some(..) => offset += 1,
                            }
                        }
                    }
                    Some(Token { kind: '/', .. }) => {
                        offset += 2;
                        while let Some(Token { kind, .. }) = parser.toks().peek_n(offset) {
                            if kind == '\n' {
                                break;
                            }
                            offset += 1;
                        }
                    }
                    // A lone slash starts an operand: dart-sass reads
                    // `5 %/ 2` as modulo by `/2`.
                    _ => return true,
                },
                _ => break,
            }
        }

        let Some(Token { kind, .. }) = parser.toks().peek_n(offset) else {
            return false;
        };

        match kind {
            '.' => !matches!(
                parser.toks().peek_n(offset + 1),
                Some(Token { kind: '.', .. })
            ),
            // Only `!important` and `!=` continue an expression; `!default`
            // and `!global` end the value, so the `%` before them is a value.
            '!' => match parser.toks().peek_n(offset + 1) {
                Some(Token {
                    kind: 'i' | 'I' | '=',
                    ..
                })
                | None => true,
                Some(Token { kind, .. }) => kind.is_ascii_whitespace(),
            },
            '(' | '[' | '\'' | '"' | '#' | '+' | '-' | '\\' | '$' | '&' | '%' => true,
            c => is_name_start(c) || c.is_ascii_digit(),
        }
    }

    /// Parses a lone `%` as the unquoted string `%`.
    fn parse_percent_value(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        parser.expect_char('%')?;

        let span = parser.toks_mut().span_from(start);

        Ok(AstExpr::String(
            StringExpr(Interpolation::new_plain("%".to_owned()), QuoteKind::None),
            span,
        )
        .span(span))
    }

    fn parse_important_expr(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        parser.expect_char('!')?;
        parser.whitespace(true)?;
        parser.expect_identifier("important", false)?;

        let span = parser.toks_mut().span_from(start);

        Ok(AstExpr::String(
            StringExpr(
                Interpolation::new_plain("!important".to_owned()),
                QuoteKind::None,
            ),
            span,
        )
        .span(span))
    }

    fn parse_identifier_like(&mut self, parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        if let Some(func) = P::IDENTIFIER_LIKE {
            return func(parser);
        }

        let start = parser.toks().cursor();

        let identifier = parser.parse_interpolated_identifier()?;

        let ident_span = parser.toks_mut().span_from(start);

        let plain = identifier.as_plain();
        let lower = plain.map(str::to_ascii_lowercase);

        if let Some(plain) = plain {
            if plain == "if" && parser.toks().next_char_is('(') {
                if ValueParser::looking_at_css_if(parser)? {
                    return ValueParser::parse_css_if(parser, start);
                }

                let call_args = parser.parse_argument_invocation(false, false)?;
                let span = call_args.span;
                return Ok(AstExpr::If(Arc::new(Ternary(call_args))).span(span));
            } else if plain == "not" {
                parser.whitespace(true)?;

                let value = self.parse_single_expression(parser)?;

                let span = parser.toks_mut().span_from(start);

                return Ok(AstExpr::UnaryOp(UnaryOp::Not, Arc::new(value.node), span).span(span));
            }

            let lower_ref = lower.as_ref().unwrap();

            if !parser.toks().next_char_is('(') {
                match plain {
                    "null" => return Ok(AstExpr::Null.span(parser.toks_mut().span_from(start))),
                    "true" => return Ok(AstExpr::True.span(parser.toks_mut().span_from(start))),
                    "false" => return Ok(AstExpr::False.span(parser.toks_mut().span_from(start))),
                    _ => {}
                }

                if let Some(color) = NAMED_COLORS.get_by_name(lower_ref.as_str()) {
                    return Ok(AstExpr::Color(Arc::new(Color::new(
                        color[0],
                        color[1],
                        color[2],
                        color[3],
                        plain.to_owned(),
                    )))
                    .span(parser.toks_mut().span_from(start)));
                }
            }

            if let Some(func) = ValueParser::try_parse_special_function(parser, lower_ref, start)? {
                return Ok(func);
            }
        }

        match parser.toks().peek() {
            Some(Token { kind: '.', .. }) => {
                if matches!(parser.toks().peek_n(1), Some(Token { kind: '.', .. })) {
                    return Ok(AstExpr::String(
                        StringExpr(identifier, QuoteKind::None),
                        parser.toks_mut().span_from(start),
                    )
                    .span(parser.toks_mut().span_from(start)));
                }
                parser.toks_mut().next();

                match plain {
                    Some(s) => Self::namespaced_expression(
                        Spanned {
                            node: Identifier::from(s),
                            span: ident_span,
                        },
                        start,
                        parser,
                    ),
                    None => Err(("Interpolation isn't allowed in namespaces.", ident_span).into()),
                }
            }
            Some(Token { kind: '(', .. }) => {
                if let Some(plain) = plain {
                    let arguments =
                        parser.parse_argument_invocation(false, lower.as_deref() == Some("var"))?;

                    Ok(AstExpr::FunctionCall(FunctionCallExpr {
                        namespace: None,
                        name: Identifier::from(plain),
                        original_name: plain.to_string(),
                        arguments: Arc::new(arguments),
                        span: parser.toks_mut().span_from(start),
                        is_custom_function: plain.starts_with("--"),
                    })
                    .span(parser.toks_mut().span_from(start)))
                } else {
                    let arguments = parser.parse_argument_invocation(false, false)?;
                    Ok(
                        AstExpr::InterpolatedFunction(Arc::new(InterpolatedFunction {
                            name: identifier,
                            arguments,
                            span: parser.toks_mut().span_from(start),
                        }))
                        .span(parser.toks_mut().span_from(start)),
                    )
                }
            }
            _ => Ok(AstExpr::String(
                StringExpr(identifier, QuoteKind::None),
                parser.toks_mut().span_from(start),
            )
            .span(parser.toks_mut().span_from(start))),
        }
    }

    fn namespaced_expression(
        namespace: Spanned<Identifier>,
        start: usize,
        parser: &mut P,
    ) -> SassResult<Spanned<AstExpr>> {
        if parser.toks().next_char_is('$') {
            let name_start = parser.toks().cursor();
            let name = parser.parse_variable_name()?;
            let span = parser.toks_mut().span_from(start);
            P::assert_public(&name, span)?;

            if parser.is_plain_css() {
                return Err(("Module namespaces aren't allowed in plain CSS.", span).into());
            }

            return Ok(AstExpr::Variable {
                name: Spanned {
                    node: Identifier::from(name),
                    span: parser.toks_mut().span_from(name_start),
                },
                namespace: Some(namespace),
            }
            .span(span));
        }

        let name = parser.parse_public_identifier()?;
        let args = parser.parse_argument_invocation(false, false)?;
        let span = parser.toks_mut().span_from(start);

        if parser.is_plain_css() {
            return Err(("Module namespaces aren't allowed in plain CSS.", span).into());
        }

        Ok(AstExpr::FunctionCall(FunctionCallExpr {
            namespace: Some(namespace),
            name: Identifier::from(name.as_str()),
            original_name: name,
            arguments: Arc::new(args),
            span,
            is_custom_function: false,
        })
        .span(span))
    }

    fn parse_unicode_range(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        parser.expect_ident_char('u', false)?;
        parser.expect_char('+')?;

        let mut first_range_length = 0;

        while let Some(next) = parser.toks().peek() {
            if !next.kind.is_ascii_hexdigit() {
                break;
            }

            parser.toks_mut().next();
            first_range_length += 1;
        }

        let mut has_question_mark = false;

        while parser.scan_char('?') {
            has_question_mark = true;
            first_range_length += 1;
        }

        let span = parser.toks_mut().span_from(start);
        if first_range_length == 0 {
            return Err(("Expected hex digit or \"?\".", parser.toks().current_span()).into());
        } else if first_range_length > 6 {
            return Err(("Expected at most 6 digits.", span).into());
        } else if has_question_mark {
            return Ok(AstExpr::String(
                StringExpr(
                    Interpolation::new_plain(parser.toks_mut().raw_text(start)),
                    QuoteKind::None,
                ),
                span,
            )
            .span(span));
        }

        if parser.scan_char('-') {
            let second_range_start = parser.toks().cursor();
            let mut second_range_length = 0;

            while let Some(next) = parser.toks().peek() {
                if !next.kind.is_ascii_hexdigit() {
                    break;
                }

                parser.toks_mut().next();
                second_range_length += 1;
            }

            if second_range_length == 0 {
                return Err(("Expected hex digit.", parser.toks().current_span()).into());
            } else if second_range_length > 6 {
                return Err((
                    "Expected at most 6 digits.",
                    parser.toks_mut().span_from(second_range_start),
                )
                    .into());
            }
        }

        if parser.looking_at_interpolated_identifier_body() {
            return Err(("Expected end of identifier.", parser.toks().current_span()).into());
        }

        let span = parser.toks_mut().span_from(start);

        Ok(AstExpr::String(
            StringExpr(
                Interpolation::new_plain(parser.toks_mut().raw_text(start)),
                QuoteKind::None,
            ),
            span,
        )
        .span(span))
    }

    pub(crate) fn try_parse_special_function(
        parser: &mut P,
        name: &str,
        start: usize,
    ) -> SassResult<Option<Spanned<AstExpr>>> {
        if matches!(parser.toks().peek(), Some(Token { kind: '(', .. }))
            && let Some(calculation) = ValueParser::try_parse_calculation(parser, name, start)?
        {
            return Ok(Some(calculation));
        }

        let normalized = unvendor(name);

        let mut buffer;

        match normalized {
            "calc" | "element" | "expression" | "type" => {
                // `type()` is special only unprefixed. dart-sass normalizes
                // `TYPE(` to `type(` but leaves `-a-type(` an ordinary
                // function call, whose arguments are Sass expressions and
                // whose quotes are normalized.
                if normalized == "type" && name != "type" {
                    return Ok(None);
                }

                if !parser.scan_char('(') {
                    return Ok(None);
                }

                buffer = Interpolation::new_plain(name.to_owned());
                buffer.add_char('(');
            }
            "progid" => {
                if !parser.scan_char(':') {
                    return Ok(None);
                }
                buffer = Interpolation::new_plain(name.to_owned());
                buffer.add_char(':');

                while let Some(Token { kind, .. }) = parser.toks().peek() {
                    if !kind.is_alphabetic() && kind != '.' {
                        break;
                    }
                    buffer.add_char(kind);
                    parser.toks_mut().next();
                }
                parser.expect_char('(')?;
                buffer.add_char('(');
            }
            "url" => {
                return Ok(parser.try_url_contents(None)?.map(|contents| {
                    AstExpr::String(
                        StringExpr(contents, QuoteKind::None),
                        parser.toks_mut().span_from(start),
                    )
                    .span(parser.toks_mut().span_from(start))
                }));
            }
            _ => return Ok(None),
        }

        let mut contents =
            parser.parse_interpolated_declaration_value(false, true, true, false, true, true)?;
        // An interpolated calc() reaches this raw-string fallback, but Dart
        // Sass serializes it without the source's leading/trailing whitespace
        // inside the parentheses (`calc( #{x} )` becomes `calc(x)`).
        //
        // This is the unprefixed name only. A vendor-prefixed one is an
        // ordinary special function, and dart-sass keeps its whitespace:
        // `-a-calc( x )` prints as written, like `element( x )` does.
        if name == "calc" {
            if let Some(InterpolationPart::String(first)) = contents.contents.first_mut() {
                *first = first.trim_start().to_owned();
            }
            if let Some(InterpolationPart::String(last)) = contents.contents.last_mut() {
                *last = last.trim_end().to_owned();
            }
            contents
                .contents
                .retain(|part| !matches!(part, InterpolationPart::String(s) if s.is_empty()));
        }
        buffer.add_interpolation(contents);
        parser.expect_char(')')?;
        buffer.add_char(')');

        Ok(Some(
            AstExpr::String(
                StringExpr(buffer, QuoteKind::None),
                parser.toks_mut().span_from(start),
            )
            .span(parser.toks_mut().span_from(start)),
        ))
    }

    /// Whether the whole argument is a single interpolation, as in `calc(#{$a})`.
    ///
    /// Dart Sass keeps such an argument as opaque text: the interpolated value
    /// reaches the output verbatim, internal whitespace and all, and nothing
    /// about it is simplified. An interpolation that merely appears *inside* a
    /// larger expression -- `calc(#{$a} + 2px)` -- does not qualify. That
    /// argument is parsed as an operation with the interpolation as one
    /// operand, which is what lets the source's whitespace be re-serialized
    /// and, when the calculation is nested inside another one, lets the
    /// operation keep the parentheses its precedence requires.
    ///
    /// The scan looks past quoted strings and comments, so neither a `#{` that
    /// is only text inside a string nor one inside a comment counts.
    fn contains_calculation_interpolation(parser: &mut P) -> SassResult<bool> {
        let start = parser.toks().cursor();
        let found = ValueParser::scan_lone_calculation_interpolation(parser)?;
        parser.toks_mut().set_cursor(start);
        Ok(found)
    }

    /// The scan behind [`Self::contains_calculation_interpolation`], leaving
    /// the cursor wherever it stopped for the caller to restore.
    fn scan_lone_calculation_interpolation(parser: &mut P) -> SassResult<bool> {
        parser.whitespace(true)?;

        if !matches!(parser.toks().peek(), Some(Token { kind: '#', .. }))
            || !matches!(parser.toks().peek_n(1), Some(Token { kind: '{', .. }))
        {
            return Ok(false);
        }

        parser.toks_mut().next();
        parser.toks_mut().next();

        let mut depth = 1_usize;

        while let Some(next) = parser.toks().peek() {
            match next.kind {
                '\\' => {
                    parser.toks_mut().next();
                    parser.toks_mut().next();
                }
                '\'' | '"' => {
                    parser.parse_interpolated_string()?;
                }
                '/' => {
                    if !parser.scan_comment()? {
                        parser.toks_mut().next();
                    }
                }
                '{' => {
                    depth += 1;
                    parser.toks_mut().next();
                }
                '}' => {
                    depth -= 1;
                    parser.toks_mut().next();
                    if depth == 0 {
                        parser.whitespace(true)?;
                        return Ok(parser.toks().next_char_is(')'));
                    }
                }
                _ => {
                    parser.toks_mut().next();
                }
            }
        }

        Ok(false)
    }

    fn try_parse_calculation_interpolation(
        parser: &mut P,
        start: usize,
    ) -> SassResult<Option<AstExpr>> {
        Ok(
            if ValueParser::contains_calculation_interpolation(parser)? {
                let mut contents = parser
                    .parse_interpolated_declaration_value(false, false, true, false, true, true)?;
                // Dart Sass serializes an interpolated calculation without the
                // source's leading/trailing whitespace inside the parentheses
                // (`calc( x )` becomes `calc(x)`).
                if let Some(InterpolationPart::String(first)) = contents.contents.first_mut() {
                    *first = first.trim_start().to_owned();
                }
                if let Some(InterpolationPart::String(last)) = contents.contents.last_mut() {
                    *last = last.trim_end().to_owned();
                }
                contents
                    .contents
                    .retain(|part| !matches!(part, InterpolationPart::String(s) if s.is_empty()));
                Some(AstExpr::String(
                    StringExpr(contents, QuoteKind::None),
                    parser.toks_mut().span_from(start),
                ))
            } else {
                None
            },
        )
    }

    /// Parses one operand of a calculation.
    ///
    /// `position` only decides what a failure is called; see
    /// [`OperandPosition`].
    fn parse_calculation_value(
        parser: &mut P,
        position: OperandPosition,
    ) -> SassResult<Spanned<AstExpr>> {
        match parser.toks().peek() {
            // A `/` at an operand position is Sass's unary slash: the binary
            // one is consumed by the product loop, which only looks after an
            // operand. It takes no whitespace to be one, unlike `+` and `-`,
            // so `calc(/ 1px)` and `calc(/1px)` are both rejected.
            Some(Token { kind: '/', .. }) => {
                let start = parser.toks().cursor();
                parser.toks_mut().next();
                parser.whitespace(true)?;
                ValueParser::parse_calculation_value(parser, OperandPosition::AfterOperator)?;

                Err((
                    "This expression can't be used in a calculation.",
                    parser.toks_mut().span_from(start),
                )
                    .into())
            }
            // A `+` or `-` with whitespace after it is a unary operator, not
            // the sign of a number, and a calculation has no unary operators.
            // Dart Sass parses `calc(+ 1px)` as one with its ordinary
            // expression parser and then rejects the expression, so the
            // operand is parsed here too and the error names the whole of it.
            Some(Token {
                kind: '+' | '-', ..
            }) if matches!(
                parser.toks().peek_n(1),
                Some(Token {
                    kind: ' ' | '\t' | '\r' | '\n',
                    ..
                })
            ) =>
            {
                let start = parser.toks().cursor();
                parser.toks_mut().next();
                parser.whitespace(true)?;
                ValueParser::parse_calculation_value(parser, OperandPosition::AfterOperator)?;

                Err((
                    "This expression can't be used in a calculation.",
                    parser.toks_mut().span_from(start),
                )
                    .into())
            }
            // A leading `-` starts an identifier in `-infinity` and `-webkit-x`
            // but a number in `-1px`, so the identifier check comes first. An
            // interpolation continues the identifier rather than ending it, so
            // `-#{$x}` is a single operand and not a minus sign.
            Some(Token { kind: '-', .. }) if parser.looking_at_interpolated_identifier() => {
                ValueParser::parse_calculation_identifier(parser)
            }
            Some(Token {
                kind: '+' | '-' | '.' | '0'..='9',
                ..
            }) => ValueParser::parse_number(parser),
            // A quoted string parses as an expression and is rejected for
            // being one, which is not the same as failing to parse: Dart Sass
            // says `calc("a")` holds an expression a calculation cannot use.
            Some(Token {
                kind: '"' | '\'', ..
            }) => {
                let start = parser.toks().cursor();
                parser.parse_string()?;

                Err((
                    "This expression can't be used in a calculation.",
                    parser.toks_mut().span_from(start),
                )
                    .into())
            }
            Some(Token { kind: '$', .. }) => ValueParser::parse_variable(parser),
            Some(Token { kind: '(', .. }) => {
                let start = parser.toks().cursor();
                parser.toks_mut().next();

                let value = match ValueParser::try_parse_calculation_interpolation(parser, start)? {
                    Some(v) => v,
                    None => {
                        parser.whitespace(true)?;

                        // `()` is the empty list, which parses and is then
                        // rejected for what it is rather than for how it is
                        // written. Dart Sass reports `calc(())` and
                        // `calc(( ))` alike.
                        if parser.scan_char(')') {
                            return Err((
                                "This expression can't be used in a calculation.",
                                parser.toks_mut().span_from(start),
                            )
                                .into());
                        }

                        ValueParser::parse_calculation_expression(parser)?.node
                    }
                };

                parser.whitespace(true)?;
                parser.expect_char(')')?;

                Ok(AstExpr::Paren(Arc::new(value)).span(parser.toks_mut().span_from(start)))
            }
            _ if !parser.looking_at_interpolated_identifier() => {
                if parser.scan_char('#') {
                    return Err((
                        ValueParser::after_hash(parser),
                        parser.toks().current_span(),
                    )
                        .into());
                }

                Err((position.no_operand(), parser.toks().current_span()).into())
            }
            _ => ValueParser::parse_calculation_identifier(parser),
        }
    }

    /// What a `#` inside a calculation turned out to be.
    ///
    /// The `#` has already been consumed. Dart Sass reads a hex colour or a
    /// name after it, so what fails depends on what follows: `#fff`, `#zzz`
    /// and `#\65` all parse into something a calculation then refuses, while a
    /// `#` with nothing usable behind it never gets that far and reports a
    /// missing identifier.
    ///
    /// A digit run is a hex colour of 3, 4, 6 or 8 digits, and Dart Sass says
    /// so when the run is another length: `#123` and `#12345678` are refused
    /// expressions, `#1`, `#12`, `#12345` and `#1234567` want another hex
    /// digit. A run longer than 8 takes the first 8 and is an expression
    /// again. Every case here was taken from dart-sass 1.103.1.
    fn after_hash(parser: &mut P) -> &'static str {
        const EXPRESSION: &str = "This expression can't be used in a calculation.";

        if parser.looking_at_identifier() {
            return EXPRESSION;
        }

        let digits = (0..)
            .take_while(|n| {
                matches!(parser.toks().peek_n(*n), Some(Token { kind, .. }) if kind.is_ascii_hexdigit())
            })
            .count();

        match digits {
            3 | 4 | 6 => EXPRESSION,
            n if n >= 8 => EXPRESSION,
            0 => "Expected identifier.",
            _ => "Expected hex digit.",
        }
    }

    /// Parses an identifier appearing inside a calculation.
    ///
    /// It is a nested calculation or function call when followed by `(`, a
    /// namespaced expression when followed by `.`, one of the calc constants
    /// when it names one, and otherwise a bare unquoted string that is carried
    /// through to the output (`calc(1px + foo)`).
    ///
    /// The identifier may contain interpolations, which bind to it rather than
    /// starting a new operand: `x#{$a}` is one value and serializes as `x1`.
    /// Such an identifier is opaque text, so it names neither a constant nor a
    /// function -- `calc(e#{""} + 1)` keeps `e` as a string instead of reading
    /// it as Euler's number -- and using it as a namespace or a call is an
    /// error, as it is in Dart Sass.
    fn parse_calculation_identifier(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let start = parser.toks().cursor();
        let contents = parser.parse_interpolated_identifier()?;
        let ident_span = parser.toks_mut().span_from(start);

        let ident = match contents.as_plain() {
            Some(plain) => plain.to_owned(),
            None => {
                return match parser.toks().peek() {
                    Some(Token { kind: '.', .. }) => {
                        Err(("Interpolation isn't allowed in namespaces.", ident_span).into())
                    }
                    Some(Token { kind: '(', .. }) => Err((
                        "This expression can't be used in a calculation.",
                        ident_span,
                    )
                        .into()),
                    _ => Ok(
                        AstExpr::String(StringExpr(contents, QuoteKind::None), ident_span)
                            .span(ident_span),
                    ),
                };
            }
        };

        if parser.scan_char('.') {
            return ValueParser::namespaced_expression(
                Spanned {
                    node: Identifier::from(&ident),
                    span: ident_span,
                },
                start,
                parser,
            );
        }

        let lowercase = ident.to_ascii_lowercase();

        if !parser.toks().next_char_is('(') {
            if let Some(constant) = calculation_constant_value(&lowercase) {
                return Ok(AstExpr::Number {
                    n: Number(constant),
                    unit: Unit::None,
                }
                .span(ident_span));
            }

            return Ok(AstExpr::String(
                StringExpr(Interpolation::new_plain(ident), QuoteKind::None),
                ident_span,
            )
            .span(ident_span));
        }

        let calculation = ValueParser::try_parse_calculation(parser, &lowercase, start)?;

        if let Some(calc) = calculation {
            Ok(calc)
        } else if lowercase == "if" {
            if ValueParser::looking_at_css_if(parser)? {
                return ValueParser::parse_css_if(parser, start);
            }

            Ok(AstExpr::If(Arc::new(Ternary(
                parser.parse_argument_invocation(false, false)?,
            )))
            .span(parser.toks_mut().span_from(start)))
        } else {
            Ok(AstExpr::FunctionCall(FunctionCallExpr {
                namespace: None,
                name: Identifier::from(&ident),
                original_name: ident.clone(),
                arguments: Arc::new(parser.parse_argument_invocation(false, false)?),
                span: parser.toks_mut().span_from(start),
                is_custom_function: ident.starts_with("--"),
            })
            .span(parser.toks_mut().span_from(start)))
        }
    }
    fn parse_calculation_product(
        parser: &mut P,
        position: OperandPosition,
    ) -> SassResult<Spanned<AstExpr>> {
        let mut product = ValueParser::parse_calculation_value(parser, position)?;

        loop {
            parser.whitespace(true)?;
            match parser.toks().peek() {
                Some(Token {
                    kind: op @ ('*' | '/'),
                    ..
                }) => {
                    parser.toks_mut().next();
                    parser.whitespace(true)?;

                    let rhs = ValueParser::parse_calculation_value(
                        parser,
                        OperandPosition::AfterOperator,
                    )?;

                    let span = product.span.merge(rhs.span);

                    product.node = AstExpr::BinaryOp(Arc::new(BinaryOpExpr {
                        lhs: product.node,
                        op: if op == '*' {
                            BinaryOp::Mul
                        } else {
                            BinaryOp::Div
                        },
                        rhs: rhs.node,
                        allows_slash: false,
                        span,
                    }));

                    product.span = span;
                }
                _ => return Ok(product),
            }
        }
    }
    fn parse_calculation_sum(
        parser: &mut P,
        position: OperandPosition,
    ) -> SassResult<Spanned<AstExpr>> {
        let mut sum = ValueParser::parse_calculation_product(parser, position)?;

        loop {
            match parser.toks().peek() {
                Some(Token {
                    kind: next @ ('+' | '-'),
                    ..
                }) => {
                    if !matches!(
                        parser.toks().peek_n_backwards(1),
                        Some(Token {
                            kind: ' ' | '\t' | '\r' | '\n',
                            ..
                        })
                    ) || !matches!(
                        parser.toks().peek_n(1),
                        Some(Token {
                            kind: ' ' | '\t' | '\r' | '\n',
                            ..
                        })
                    ) {
                        return Err((
                            "\"+\" and \"-\" must be surrounded by whitespace in calculations.",
                            parser.toks().current_span(),
                        )
                            .into());
                    }

                    parser.toks_mut().next();
                    parser.whitespace(true)?;

                    let rhs = ValueParser::parse_calculation_product(
                        parser,
                        OperandPosition::AfterOperator,
                    )?;

                    let span = sum.span.merge(rhs.span);

                    sum = AstExpr::BinaryOp(Arc::new(BinaryOpExpr {
                        lhs: sum.node,
                        op: if next == '+' {
                            BinaryOp::Plus
                        } else {
                            BinaryOp::Minus
                        },
                        rhs: rhs.node,
                        allows_slash: false,
                        span,
                    }))
                    .span(span);
                }
                _ => return Ok(sum),
            }
        }
    }

    /// Parses one calculation argument, the level at which values written next
    /// to each other with only whitespace between them form a space-separated
    /// list.
    ///
    /// Adjacency binds looser than any operator, so `calc(var(--c) 1 + 2px)`
    /// is `var(--c)` next to `1 + 2px`, not `var(--c) 1` plus `2px`. Dart Sass
    /// parses a calculation argument as an ordinary Sass expression, where a
    /// space-separated list binds loosest of all, and this mirrors that. It is
    /// also what keeps the serializer's parenthesization honest: an operand
    /// that is a space-separated list then always came from a grouping the
    /// source wrote -- parentheses, or a nested `calc()` -- which is exactly
    /// when the output needs parentheses back.
    fn parse_calculation_expression(parser: &mut P) -> SassResult<Spanned<AstExpr>> {
        let mut expr = ValueParser::parse_calculation_sum(parser, OperandPosition::ArgumentStart)?;

        loop {
            match parser.toks().peek() {
                // Two values written next to each other with only whitespace
                // between them are legal in a calculation when at least one is
                // opaque, as in `calc(var(--c) 1)`. Only a variable, a number
                // or an identifier (which is how both `var()` and an
                // interpolation start) can begin such a continuation.
                Some(Token {
                    kind: '$' | '(' | '.' | '0'..='9',
                    ..
                }) => {
                    expr = ValueParser::parse_calculation_adjacent(parser, expr)?;
                }
                Some(..) if parser.looking_at_interpolated_identifier() => {
                    expr = ValueParser::parse_calculation_adjacent(parser, expr)?;
                }
                _ => return Ok(expr),
            }
        }
    }

    /// Collects a whitespace-separated continuation of a calculation value into
    /// a space-separated list.
    fn parse_calculation_adjacent(
        parser: &mut P,
        first: Spanned<AstExpr>,
    ) -> SassResult<Spanned<AstExpr>> {
        let next = ValueParser::parse_calculation_sum(parser, OperandPosition::ArgumentStart)?;
        let span = first.span.merge(next.span);

        let mut elems = match first.node {
            AstExpr::List(list)
                if list.separator == ListSeparator::Space && list.brackets == Brackets::None =>
            {
                list.elems
            }
            node => vec![node.span(first.span)],
        };

        elems.push(next);

        Ok(AstExpr::List(ListExpr {
            elems,
            separator: ListSeparator::Space,
            brackets: Brackets::None,
        })
        .span(span))
    }

    /// Decides between the CSS `if()` and the Sass ternary of the same name.
    ///
    /// The scanner is left where it started. The two forms are told apart the
    /// way a reader tells them apart: the CSS form separates branches with `;`
    /// and a condition from its value with `:`, while the ternary separates its
    /// three arguments with `,`. Whichever of those appears first at the top
    /// level of the argument list decides.
    fn looking_at_css_if(parser: &mut P) -> SassResult<bool> {
        debug_assert!(parser.toks().next_char_is('('));

        let start = parser.toks().cursor();
        let mut depth = 0_usize;
        let mut result = false;

        while let Some(tok) = parser.toks().peek() {
            match tok.kind {
                '(' | '[' | '{' => {
                    depth += 1;
                    parser.toks_mut().next();
                }
                ')' | ']' | '}' => {
                    depth -= 1;
                    parser.toks_mut().next();

                    if depth == 0 {
                        break;
                    }
                }
                '"' | '\'' => {
                    let quote = tok.kind;
                    parser.toks_mut().next();

                    while let Some(tok) = parser.toks().peek() {
                        parser.toks_mut().next();

                        if tok.kind == '\\' {
                            parser.toks_mut().next();
                        } else if tok.kind == quote {
                            break;
                        }
                    }
                }
                // A `$name:` at the top level is a named argument of the Sass
                // ternary, not a CSS branch condition.
                '$' if depth == 1 => {
                    parser.toks_mut().next();

                    while let Some(tok) = parser.toks().peek() {
                        if !tok.kind.is_alphanumeric() && !matches!(tok.kind, '-' | '_') {
                            break;
                        }

                        parser.toks_mut().next();
                    }

                    let before_colon = parser.toks().cursor();
                    parser.whitespace_without_comments(true);

                    if parser.toks().next_char_is(':') {
                        parser.toks_mut().next();
                    } else {
                        parser.toks_mut().set_cursor(before_colon);
                    }
                }
                ':' | ';' if depth == 1 => {
                    result = true;
                    break;
                }
                ',' if depth == 1 => break,
                _ => {
                    parser.toks_mut().next();
                }
            }
        }

        parser.toks_mut().set_cursor(start);

        Ok(result)
    }

    /// Parses `if(<condition>: <value>; ...)`.
    pub(crate) fn parse_css_if(parser: &mut P, start: usize) -> SassResult<Spanned<AstExpr>> {
        parser.expect_char('(')?;

        let mut branches = Vec::new();

        loop {
            parser.whitespace(true)?;

            if !branches.is_empty() && parser.toks().next_char_is(')') {
                break;
            }

            let condition = ValueParser::parse_css_if_condition(parser, true)?;
            parser.whitespace(true)?;
            parser.expect_char(':')?;
            parser.whitespace(true)?;

            let value = ValueParser::parse_css_if_value(parser)?;

            branches.push(CssIfBranch { condition, value });

            parser.whitespace(true)?;

            if !parser.scan_char(';') {
                break;
            }
        }

        parser.whitespace(true)?;
        parser.expect_char(')')?;

        let span = parser.toks_mut().span_from(start);

        Ok(AstExpr::CssIf(Arc::new(CssIfExpr { branches })).span(span))
    }

    /// Parses the value half of a branch: everything up to the `;` that starts
    /// the next branch or the `)` that ends the function.
    fn parse_css_if_value(parser: &mut P) -> SassResult<AstExpr> {
        Ok(ValueParser::parse_expression(
            parser,
            Some(&|parser| {
                Ok(matches!(
                    parser.toks().peek(),
                    Some(Token {
                        kind: ';' | ')',
                        ..
                    })
                ))
            }),
            true,
            false,
            false,
        )?
        .node)
    }

    /// Parses a whole branch condition, including the `and`/`or` chain.
    ///
    /// CSS does not allow `and` and `or` to mix without parentheses, so once a
    /// chain commits to one operator the other is a syntax error. `else` is a
    /// whole condition on its own and is not allowed inside one, which is why
    /// it is gated on `allow_else`.
    fn parse_css_if_condition(parser: &mut P, allow_else: bool) -> SassResult<CssIfCondition> {
        if allow_else && ValueParser::scan_css_if_keyword(parser, "else")? {
            return Ok(CssIfCondition::Else);
        }

        if ValueParser::scan_css_if_keyword(parser, "not")? {
            parser.whitespace(true)?;

            // `not` takes a single term, not a chain: `not a and b` is a syntax
            // error rather than `(not a) and b` or `not (a and b)`.
            let (condition, ..) = ValueParser::css_if_atom_as_test(parser)?;

            return Ok(CssIfCondition::Not(Box::new(condition)));
        }

        let mut tests = vec![ValueParser::parse_css_if_test(parser)?];
        let mut operator = None;

        loop {
            let before = parser.toks().cursor();
            parser.whitespace(true)?;

            let next = if ValueParser::scan_css_if_keyword(parser, "and")? {
                "and"
            } else if ValueParser::scan_css_if_keyword(parser, "or")? {
                "or"
            } else {
                parser.toks_mut().set_cursor(before);
                break;
            };

            match operator {
                None => operator = Some(next),
                Some(seen) if seen == next => {}
                Some(..) => return Err((r#"expected ":"."#, parser.toks().current_span()).into()),
            }

            parser.whitespace(true)?;
            tests.push(ValueParser::parse_css_if_test(parser)?);
        }

        // A substitution sitting next to other terms could expand to anything,
        // operators included, so Sass cannot tell which part of the surrounding
        // chain its neighbours belong to. Mixing one with a `sass()` the
        // compiler must resolve is therefore rejected rather than guessed at.
        // Parentheses bound the ambiguity and make the combination legal again.
        if tests.iter().any(|(_, is_raw_run, _)| *is_raw_run)
            && tests.iter().any(|(_, _, has_sass)| *has_sass)
        {
            return Err((
                "if() conditions with arbitrary substitutions may not contain sass() expressions.",
                parser.toks().current_span(),
            )
                .into());
        }

        let mut conditions = tests.into_iter().map(|(condition, ..)| condition);

        Ok(match operator {
            None => conditions.next().unwrap(),
            Some("and") => CssIfCondition::And(conditions.collect()),
            Some(..) => CssIfCondition::Or(conditions.collect()),
        })
    }

    /// Scans one of the condition keywords, but only where it really is a
    /// keyword.
    ///
    /// `not(...)` is a function call, not the operator, and CSS rejects it
    /// outright rather than silently reinterpreting it, so a keyword followed
    /// immediately by `(` is an error.
    fn scan_css_if_keyword(parser: &mut P, keyword: &str) -> SassResult<bool> {
        let start = parser.toks().cursor();

        if !parser.looking_at_identifier() {
            return Ok(false);
        }

        let ident = parser.parse_identifier(false, false)?;

        if !ident.eq_ignore_ascii_case(keyword) {
            parser.toks_mut().set_cursor(start);
            return Ok(false);
        }

        ValueParser::reject_keyword_call(parser, &ident)?;

        Ok(true)
    }

    /// Rejects `not(`, `and(` and `or(`, which CSS treats as a mistake rather
    /// than as a function call.
    fn reject_keyword_call(parser: &mut P, ident: &str) -> SassResult<()> {
        if parser.toks().next_char_is('(') {
            return Err((
                format!(r#"Whitespace is required between "{}" and "(""#, ident),
                parser.toks().current_span(),
            )
                .into());
        }

        Ok(())
    }

    /// Parses one operand of a chain: either a single term or a run of terms
    /// separated only by whitespace.
    ///
    /// Returns the condition along with whether it is such a run and whether it
    /// contains a `sass()` expression anywhere, which is what the caller needs
    /// to police the two of them appearing together.
    fn parse_css_if_test(parser: &mut P) -> SassResult<(CssIfCondition, bool, bool)> {
        let start = parser.toks().cursor();
        let first = ValueParser::parse_css_if_atom(parser)?;

        // A parenthesized condition is always complete in itself; nothing may
        // run on from it.
        if let CssIfAtom::Paren(condition) = first {
            let has_sass = condition_contains_sass(&condition);
            return Ok((CssIfCondition::Paren(Box::new(condition)), false, has_sass));
        }

        let mut has_sass = matches!(first, CssIfAtom::Sass(..));
        let mut terms = 1;

        loop {
            let before = parser.toks().cursor();
            parser.whitespace(true)?;

            match parser.toks().peek() {
                None
                | Some(Token {
                    kind: ':' | ';' | ')' | ',',
                    ..
                }) => {
                    parser.toks_mut().set_cursor(before);
                    break;
                }
                _ => {}
            }

            // An `and` or `or` here belongs to the enclosing chain.
            let after_whitespace = parser.toks().cursor();
            if ValueParser::peek_css_if_operator(parser)? {
                parser.toks_mut().set_cursor(before);
                break;
            }
            parser.toks_mut().set_cursor(after_whitespace);

            match ValueParser::parse_css_if_atom(parser)? {
                // A run of substitutions has no place for a parenthesized
                // condition: `a (b) c` is not a condition Sass can read.
                CssIfAtom::Paren(..) => {
                    return Err((r#"expected ":"."#, parser.toks().current_span()).into());
                }
                CssIfAtom::Sass(..) => has_sass = true,
                CssIfAtom::Raw(..) => {}
            }

            terms += 1;
        }

        if terms == 1 {
            return Ok((
                match first {
                    CssIfAtom::Sass(expr) => CssIfCondition::Sass(Arc::new(expr)),
                    CssIfAtom::Raw(interpolation) => CssIfCondition::Raw(Arc::new(interpolation)),
                    CssIfAtom::Paren(..) => unreachable!("handled above"),
                },
                false,
                has_sass,
            ));
        }

        // Re-read the whole run as text so that it is emitted exactly as it was
        // written, with only its interpolations resolved.
        let end = parser.toks().cursor();
        parser.toks_mut().set_cursor(start);
        let raw = ValueParser::parse_css_if_raw_text(parser, end)?;

        Ok((CssIfCondition::Raw(Arc::new(raw)), true, has_sass))
    }

    /// Parses exactly one term where a chain is not allowed, as after `not`.
    fn css_if_atom_as_test(parser: &mut P) -> SassResult<(CssIfCondition, bool, bool)> {
        Ok(match ValueParser::parse_css_if_atom(parser)? {
            CssIfAtom::Sass(expr) => (CssIfCondition::Sass(Arc::new(expr)), false, true),
            CssIfAtom::Raw(interpolation) => {
                (CssIfCondition::Raw(Arc::new(interpolation)), false, false)
            }
            CssIfAtom::Paren(condition) => {
                let has_sass = condition_contains_sass(&condition);
                (CssIfCondition::Paren(Box::new(condition)), false, has_sass)
            }
        })
    }

    /// Whether the scanner is at an `and` or `or` that separates operands.
    fn peek_css_if_operator(parser: &mut P) -> SassResult<bool> {
        let start = parser.toks().cursor();

        if !parser.looking_at_identifier() {
            return Ok(false);
        }

        let ident = parser.parse_identifier(false, false)?;
        let is_operator = ident.eq_ignore_ascii_case("and") || ident.eq_ignore_ascii_case("or");
        parser.toks_mut().set_cursor(start);

        Ok(is_operator)
    }

    /// Re-reads the source between the current position and `end` as an
    /// interpolation, collapsing runs of whitespace to a single space so the
    /// output is normalized the way Dart Sass normalizes it.
    fn parse_css_if_raw_text(parser: &mut P, end: usize) -> SassResult<Interpolation> {
        let mut buffer = Interpolation::new();
        let mut pending_space = false;

        while parser.toks().cursor() < end {
            match parser.toks().peek() {
                Some(Token { kind: '#', .. })
                    if matches!(parser.toks().peek_n(1), Some(Token { kind: '{', .. })) =>
                {
                    if pending_space {
                        buffer.add_char(' ');
                        pending_space = false;
                    }

                    buffer.add_interpolation(parser.parse_single_interpolation()?);
                }
                Some(Token { kind, .. }) if kind.is_ascii_whitespace() => {
                    pending_space = !buffer.is_empty();
                    parser.toks_mut().next();
                }
                Some(Token { kind, .. }) => {
                    if pending_space {
                        buffer.add_char(' ');
                        pending_space = false;
                    }

                    buffer.add_char(kind);
                    parser.toks_mut().next();
                }
                None => break,
            }
        }

        Ok(buffer)
    }

    /// Parses a single term of a condition.
    fn parse_css_if_atom(parser: &mut P) -> SassResult<CssIfAtom> {
        let start = parser.toks().cursor();

        if parser.toks().next_char_is('(') {
            parser.toks_mut().next();
            parser.whitespace(true)?;
            let condition = ValueParser::parse_css_if_condition(parser, false)?;
            parser.whitespace(true)?;
            parser.expect_char(')')?;
            return Ok(CssIfAtom::Paren(condition));
        }

        let is_interpolation = matches!(parser.toks().peek(), Some(Token { kind: '#', .. }))
            && matches!(parser.toks().peek_n(1), Some(Token { kind: '{', .. }));

        if !is_interpolation && !parser.looking_at_identifier() {
            return Err(("Expected identifier.", parser.toks().current_span()).into());
        }

        let name = parser.parse_interpolated_identifier()?;

        if let Some(plain) = name.as_plain() {
            if plain.eq_ignore_ascii_case("sass") {
                parser.expect_char('(')?;
                parser.whitespace(true)?;
                let expr = ValueParser::parse_expression(
                    parser,
                    Some(&|parser| Ok(parser.toks().next_char_is(')'))),
                    true,
                    false,
                    false,
                )?;
                parser.whitespace(true)?;
                parser.expect_char(')')?;

                // A `sass()` condition is settled at compile time, which a
                // `.css` file has no business doing.
                if parser.is_plain_css() {
                    return Err((
                        "sass() conditions aren't allowed in plain CSS",
                        parser.toks_mut().span_from(start),
                    )
                        .into());
                }

                return Ok(CssIfAtom::Sass(expr.node));
            }

            if matches!(
                plain.to_ascii_lowercase().as_str(),
                "not" | "and" | "or" | "else"
            ) {
                ValueParser::reject_keyword_call(parser, plain)?;
            }

            // A plain identifier that is not a function call is not a term.
            if !parser.toks().next_char_is('(') {
                return Err((r#"expected "("."#, parser.toks().current_span()).into());
            }
        }

        // A bare interpolation stands on its own; anything else is a
        // function-shaped term whose text the browser resolves.
        if !parser.toks().next_char_is('(') {
            return Ok(CssIfAtom::Raw(name));
        }

        parser.toks_mut().next();

        let mut buffer = name;
        buffer.add_char('(');
        buffer.add_interpolation(ValueParser::parse_css_if_function_argument(parser)?);
        parser.expect_char(')')?;
        buffer.add_char(')');

        Ok(CssIfAtom::Raw(buffer))
    }

    /// Reads the argument text of an opaque condition term, up to but not
    /// including the `)` that closes it.
    ///
    /// The text is copied character for character rather than re-parsed, so
    /// that whatever the author wrote reaches the browser unchanged -- an empty
    /// `''` stays single-quoted instead of being re-quoted. Only interpolation
    /// is resolved, including inside quoted strings, where Sass resolves it too.
    fn parse_css_if_function_argument(parser: &mut P) -> SassResult<Interpolation> {
        let mut buffer = Interpolation::new();
        let mut brackets = Vec::new();
        let mut quote = None;

        while let Some(tok) = parser.toks().peek() {
            match tok.kind {
                '\\' => {
                    buffer.add_char('\\');
                    parser.toks_mut().next();

                    if let Some(escaped) = parser.toks().peek() {
                        buffer.add_char(escaped.kind);
                        parser.toks_mut().next();
                    }
                }
                '#' if matches!(parser.toks().peek_n(1), Some(Token { kind: '{', .. })) => {
                    buffer.add_interpolation(parser.parse_single_interpolation()?);
                }
                '"' | '\'' => {
                    match quote {
                        Some(open) if open == tok.kind => quote = None,
                        Some(..) => {}
                        None => quote = Some(tok.kind),
                    }

                    buffer.add_char(tok.kind);
                    parser.toks_mut().next();
                }
                _ if quote.is_some() => {
                    buffer.add_char(tok.kind);
                    parser.toks_mut().next();
                }
                '(' | '[' | '{' => {
                    brackets.push(opposite_bracket(tok.kind));
                    buffer.add_char(tok.kind);
                    parser.toks_mut().next();
                }
                ')' | ']' | '}' => {
                    if brackets.last() != Some(&tok.kind) {
                        break;
                    }

                    brackets.pop();
                    buffer.add_char(tok.kind);
                    parser.toks_mut().next();
                }
                _ => {
                    buffer.add_char(tok.kind);
                    parser.toks_mut().next();
                }
            }
        }

        Ok(buffer)
    }

    /// Parses the parenthesized argument list of a CSS math function.
    ///
    /// The list may be empty and may carry a trailing comma; how many arguments
    /// a given function actually accepts is checked during evaluation, which is
    /// where Dart Sass reports it too.
    fn parse_calculation_arguments(parser: &mut P, start: usize) -> SassResult<Vec<AstExpr>> {
        parser.expect_char('(')?;
        if let Some(interpolation) =
            ValueParser::try_parse_calculation_interpolation(parser, start)?
        {
            parser.expect_char(')')?;
            return Ok(vec![interpolation]);
        }

        parser.whitespace(true)?;

        let mut arguments = Vec::new();

        if !parser.toks().next_char_is(')') {
            arguments.push(ValueParser::parse_calculation_expression(parser)?.node);
            parser.whitespace(true)?;

            while parser.scan_char(',') {
                parser.whitespace(true)?;

                if parser.toks().next_char_is(')') {
                    break;
                }

                arguments.push(ValueParser::parse_calculation_expression(parser)?.node);
                parser.whitespace(true)?;
            }
        }

        ValueParser::reject_non_calculation_operator(parser)?;
        parser.expect_char(')')?;

        Ok(arguments)
    }

    /// Rejects a SassScript binary operator a calculation cannot use.
    ///
    /// A calculation has four operators; SassScript has more, and dart-sass
    /// names the difference rather than reporting a missing `)`. `!` counts
    /// only as the start of `!=`: `calc(1px !)` is a malformed call and
    /// dart-sass reports it as one, as it does for `^`. Checked against
    /// dart-sass 1.103.1 for `%`, `<`, `<=`, `>`, `>=`, `=`, `==`, `!=`, `!`
    /// and `^`.
    ///
    /// `&` is a known divergence rather than a member of either group.
    /// dart-sass reads it as the parent selector, so `calc(1px & 2px)` holds
    /// an expression a calculation cannot use; this reports a missing `)`.
    /// Recorded in
    /// `specs/docs/features/08-calculation-warnings-and-error-wording.md`.
    ///
    /// The word operators `and` and `or` do not reach here. They read as
    /// identifiers, so `calc(1px and 2px)` becomes a space-separated list and
    /// is carried through to the output, where dart-sass rejects it. That is a
    /// separate gap, recorded in
    /// `specs/docs/features/08-calculation-warnings-and-error-wording.md`.
    fn reject_non_calculation_operator(parser: &mut P) -> SassResult<()> {
        let start = parser.toks().cursor();

        // The width is the operator's, so the span covers `<=` and `!=` whole
        // rather than pointing at half of one.
        let width = match parser.toks().peek() {
            Some(Token { kind: '%', .. }) => 1,
            Some(Token {
                kind: '<' | '>' | '=',
                ..
            }) => {
                if matches!(parser.toks().peek_n(1), Some(Token { kind: '=', .. })) {
                    2
                } else {
                    1
                }
            }
            Some(Token { kind: '!', .. })
                if matches!(parser.toks().peek_n(1), Some(Token { kind: '=', .. })) =>
            {
                2
            }
            _ => return Ok(()),
        };

        for _ in 0..width {
            parser.toks_mut().next();
        }

        Err((
            "This operation can't be used in a calculation.",
            parser.toks_mut().span_from(start),
        )
            .into())
    }

    /// Parses `name(...)` as a CSS math function if `name` is one.
    ///
    /// Arguments that are not calculation syntax rewind the scanner and return
    /// `None`, so the ordinary function-call parser gets them instead. That is
    /// what keeps a user-defined `log("...")` or `mod($a, $b)` working, and it
    /// is also how the Sass `min`, `max`, `round` and `abs` functions receive
    /// arguments a calculation could not express. A math name that resolves to
    /// no function at all is rejected when it is evaluated.
    fn try_parse_calculation(
        parser: &mut P,
        name: &str,
        start: usize,
    ) -> SassResult<Option<Spanned<AstExpr>>> {
        debug_assert!(parser.toks().next_char_is('('));

        let name = match CalculationName::from_lowercase_str(name) {
            Some(name) => name,
            None => return Ok(None),
        };

        let before_args = parser.toks().cursor();

        let args = match ValueParser::parse_calculation_arguments(parser, start) {
            Ok(args) => args,
            Err(err) => {
                // `calc` is a reserved identifier, so nothing can be hiding
                // behind it; rewinding would only hand the arguments to the
                // raw-text special-function parser, which accepts anything.
                if name == CalculationName::Calc {
                    return Err(err);
                }

                parser.toks_mut().set_cursor(before_args);
                return Ok(None);
            }
        };

        Ok(Some(
            AstExpr::Calculation { name, args }.span(parser.toks_mut().span_from(start)),
        ))
    }

    fn reset_state(&mut self, parser: &mut P) -> SassResult<()> {
        self.comma_expressions = None;
        self.space_expressions = None;
        self.binary_operators = None;
        self.operands = None;
        parser.toks_mut().set_cursor(self.start);
        self.allow_slash = true;
        self.single_expression = Some(self.parse_single_expression(parser)?);

        Ok(())
    }
}