oxc_css_parser/parser/

stmt.rs

use super::{
    Parser,
    state::{ParserState, QualifiedRuleContext},
};
use crate::{
    Parse, Syntax,
    ast::*,
    error::{Error, ErrorKind, PResult},
    pos::Span,
    tokenizer::{Token, TokenWithSpan},
};

// https://drafts.csswg.org/css-syntax-3/#consume-declaration
//
// <declaration> = <ident-token> : <declaration-value>? [ '!' important ]?
impl<'a> Parse<'a> for Declaration<'a> {
    fn parse(input: &mut Parser<'a>) -> PResult<Self> {
        // Legacy IE hacks glued to the property name: `*color: red` targets
        // IE<=7; dart-sass's plain-CSS parser additionally accepts `:x`, `.x`
        // and `#x` prefixes. Keep them as a property-name prefix — but only
        // when glued: `* color` (whitespace or a comment after the sigil) is
        // not the hack, so leave the token for the normal (failing) parse.
        let mut name_prefix = if input.state.allow_ie_star_hack
            && let TokenWithSpan { token, span } = input.cursor.peek()?
            && let Some(prefix) = match token {
                Token::Asterisk(..) => Some('*'),
                Token::Dot(..) if input.syntax == Syntax::Css => Some('.'),
                Token::Colon(..) if input.syntax == Syntax::Css => Some(':'),
                _ => None,
            }
            && input
                .source
                .as_bytes()
                .get(span.end)
                .is_some_and(|b| !b.is_ascii_whitespace() && *b != b'/')
        {
            let start = span.start;
            input.cursor.bump()?;
            Some((start, prefix))
        } else {
            None
        };
        // A css-in-js `${}` placeholder may stand in for the property name
        // (`${foo}: ${bar}`); it is not a real ident, so accept it directly.
        let name = if let Token::Placeholder(..) = input.cursor.peek()?.token {
            let (placeholder, span) = input.cursor.expect_placeholder()?;
            InterpolableIdent::Placeholder((placeholder, span).into())
        } else if input.state.allow_ie_star_hack
            && input.syntax == Syntax::Less
            && let token = input.cursor.peek()?
            && let Some(raw) = token.number_raw(input.source)
            && raw.bytes().all(|b| b.is_ascii_digit())
        {
            let span = token.span;
            input.cursor.bump()?;
            InterpolableIdent::Literal(Ident { name: raw, raw, span })
        } else if name_prefix.is_none()
            && input.state.allow_ie_star_hack
            && input.syntax == Syntax::Css
            && matches!(input.cursor.peek()?.token, Token::Hash(..))
        {
            // `#x: y` — the `#` and the name arrive as one <hash-token>.
            let token @ TokenWithSpan { token: Token::Hash(..), span } = input.cursor.bump()?
            else {
                unreachable!()
            };
            let hash = token.hash(input.source).unwrap();
            name_prefix = Some((span.start, '#'));
            let name = if hash.escaped {
                crate::util::handle_escape_in(hash.raw, input.allocator)
            } else {
                hash.raw
            };
            InterpolableIdent::Literal(Ident {
                name,
                raw: hash.raw,
                span: Span { start: span.start + 1, end: span.end },
            })
        } else {
            input
                .with_state(ParserState {
                    qualified_rule_ctx: Some(QualifiedRuleContext::DeclarationName),
                    ..input.state
                })
                .parse::<InterpolableIdent>()?
        };

        // https://tailwindcss.com/docs/theme#overriding-the-default-theme
        let name_suffix = if let TokenWithSpan { token: Token::Asterisk(..), span } =
            input.cursor.peek()?
            && name.span().end == span.start
        {
            input.cursor.bump()?;
            Some('*')
        } else {
            None
        };

        // Less property merge (`prop+: v`, `prop+_: v`) — also accepted for
        // plain CSS since Less serializes the flag into its output.
        let less_property_merge =
            if matches!(input.syntax, Syntax::Less | Syntax::Css) { input.parse()? } else { None };

        let (_, colon_span) = input.cursor.expect_colon()?;
        let (mut value, mut important) = {
            let mut parser = input.with_state(ParserState {
                qualified_rule_ctx: Some(QualifiedRuleContext::DeclarationValue),
                ..input.state
            });
            // For IE-compatibility, regardless of the property name (`filter`,
            // `-ms-filter`, vendor variants...): `filter: progid:...`.
            let source = parser.source;
            let starts_with_progid =
                parser.cursor.peek()?.is_ident_name_eq_ignore_ascii_case(source, "progid");
            match &name {
                InterpolableIdent::Literal(ident)
                    if ident.name.starts_with("--") || starts_with_progid =>
                'value: {
                    if parser.options.try_parsing_value_in_custom_property
                        && let Ok(values) = parser.try_parse(Parser::parse_declaration_value)
                    {
                        break 'value (values, None);
                    }
                    (parser.parse_declaration_value_tokens(false)?, None)
                }
                // In CSS, a declaration value is any sequence of component
                // values (CSS Syntax §5): serialized selectors (`b: .c > d`),
                // map-like blocks (`b: (3: 4)`), or stray delimiters are all
                // valid preserved tokens even though the typed grammar has no
                // node for them. Try the typed grammar first; if it fails, or
                // succeeds without accounting for everything up to the
                // declaration terminator, re-parse the whole value as raw
                // tokens. Scss/Sass/Less keep the strict grammar: their
                // dialects assign meaning to these tokens and are expected to
                // reject exactly what their reference compilers reject.
                _ if parser.syntax == Syntax::Css
                    || (parser.state.in_css_function_body
                        && matches!(&name, InterpolableIdent::Literal(..))) =>
                {
                    let typed = parser.try_parse(|p| {
                        let values = p.parse_declaration_value()?;
                        let important = match &p.cursor.peek()?.token {
                            Token::Exclamation(..) => Some(p.parse::<ImportantAnnotation>()?),
                            _ => None,
                        };
                        let next = p.cursor.peek()?;
                        if at_declaration_value_end(&next.token) {
                            Ok((values, important))
                        } else {
                            Err(Error { kind: ErrorKind::ExpectComponentValue, span: next.span })
                        }
                    });
                    match typed {
                        Ok(value_and_important) => value_and_important,
                        Err(_) => {
                            // A CSS custom function body holds declarations only,
                            // so a top-level `{}` there is part of the value;
                            // elsewhere it means this construct is really a qualified rule
                            // (CSS Nesting disambiguation) and the declaration is rejected.
                            let in_fn_body = parser.state.in_css_function_body;
                            let values = parser.parse_declaration_value_tokens(!in_fn_body)?;
                            let next = parser.cursor.peek()?;
                            if !in_fn_body && let Token::LBrace(..) = next.token {
                                return Err(Error {
                                    kind: ErrorKind::BlockInDeclarationValue,
                                    span: next.span,
                                });
                            }
                            (values, None)
                        }
                    }
                }
                _ => (parser.parse_declaration_value()?, None),
            }
        };

        if important.is_none()
            && let Token::Exclamation(..) = &input.cursor.peek()?.token
        {
            important = Some(input.parse::<ImportantAnnotation>()?);
        }
        // dart-sass allows `!important` mid-value (`fludge: foo bar
        // !important hux;`): when more value follows, the annotation is just
        // another component, and only a trailing one is structural.
        while matches!(input.syntax, Syntax::Scss | Syntax::Sass)
            && important.is_some()
            && !at_declaration_value_end(&input.cursor.peek()?.token)
        {
            if let Some(annotation) = important.take() {
                value.push(ComponentValue::ImportantAnnotation(annotation));
            }
            let more = input
                .with_state(ParserState {
                    qualified_rule_ctx: Some(QualifiedRuleContext::DeclarationValue),
                    ..input.state
                })
                .parse_declaration_value()?;
            for component in more {
                value.push(component);
            }
            if let Token::Exclamation(..) = &input.cursor.peek()?.token {
                important = Some(input.parse::<ImportantAnnotation>()?);
            }
        }

        let span = Span {
            start: name_prefix.map_or(name.span().start, |(start, _)| start),
            end: if let Some(important) = &important {
                important.span.end
            } else if let Some(last) = value.last() {
                last.span().end
            } else {
                colon_span.end
            },
        };
        Ok(Declaration {
            name,
            name_prefix: name_prefix.map(|(_, prefix)| prefix),
            name_suffix,
            colon_span,
            value,
            important,
            less_property_merge,
            span,
        })
    }
}

/// End of a declaration's value: the declaration terminator tokens.
fn at_declaration_value_end(token: &Token) -> bool {
    matches!(
        token,
        Token::Semicolon(..)
            | Token::RBrace(..)
            | Token::RParen(..)
            | Token::Dedent(..)
            | Token::Linebreak(..)
            | Token::Eof(..)
    )
}

// <important> = '!' important
impl<'a> Parse<'a> for ImportantAnnotation<'a> {
    fn parse(input: &mut Parser<'a>) -> PResult<Self> {
        let (_, span) = input.cursor.expect_exclamation()?;
        input.eat_sass_line_continuation()?;
        let ident: Ident = input.parse::<Ident>()?;
        let span = Span { start: span.start, end: ident.span.end };
        if ident.name.eq_ignore_ascii_case("important") {
            Ok(ImportantAnnotation { ident, span })
        } else {
            Err(Error { kind: ErrorKind::ExpectImportantAnnotation, span })
        }
    }
}

// https://drafts.csswg.org/css-syntax-3/#consume-qualified-rule
//
// <qualified-rule> = <prelude> <{}-block>
// In a style context the prelude is a selector list:
//   <style-rule> = <selector-list> { <style-block> }
impl<'a> Parse<'a> for QualifiedRule<'a> {
    fn parse(input: &mut Parser<'a>) -> PResult<Self> {
        let selector_list = input
            .with_state(ParserState {
                qualified_rule_ctx: Some(QualifiedRuleContext::Selector),
                ..input.state
            })
            .parse::<SelectorList>()?;
        let block = input.parse::<SimpleBlock>()?;
        let span = Span { start: selector_list.span.start, end: block.span.end };
        Ok(QualifiedRule { selector: selector_list, block, span })
    }
}

// https://drafts.csswg.org/css-syntax-3/#consume-block-contents
//
// <unknown-qualified-rule> = <ident-token> ':' <any-value> <{}-block>
//
// The §5.5.5 re-consume of a statement rejected as a declaration by §5.5.6
// (`BlockInDeclarationValue`): the prelude matches no selector grammar,
// so it is kept as raw tokens.
// postcss keeps such rules too
// (postcss-nested-style dialects use the shape for nested config blocks),
// and Prettier prints the prelude verbatim.
impl<'a> Parse<'a> for UnknownQualifiedRule<'a> {
    fn parse(input: &mut Parser<'a>) -> PResult<Self> {
        debug_assert!(input.syntax == Syntax::Css);
        let prelude = input.parse_raw_prelude_tokens()?;
        // The scan also stops at `;` / statement boundaries;
        // `SimpleBlock`'s `expect_l_brace` rejects those, so only a block opener makes this shape.
        let block = input.parse::<SimpleBlock>()?;
        let span = Span { start: prelude.span.start, end: block.span.end };
        Ok(UnknownQualifiedRule { prelude, block, span })
    }
}

// https://drafts.csswg.org/css-syntax-3/#consume-simple-block
//
// <simple-block> = '{' <block-contents> '}'
// (Sass indented syntax substitutes Indent/Dedent for the braces.)
impl<'a> Parse<'a> for SimpleBlock<'a> {
    fn parse(input: &mut Parser<'a>) -> PResult<Self> {
        let is_sass = input.syntax == Syntax::Sass;
        let start = if is_sass {
            // A continuation line deeper than this block's own level leaves a
            // pending indent whose `Dedent` arrives before the block opens
            // (`a,\n    b\n  c: d`); cancel those out first.
            let drained = input.drain_sass_pending_dedents()?;
            if let Some((_, span)) = input.cursor.eat_indent()? {
                span.end
            } else if drained
                && input.sass_pending_indents == 0
                && input.cursor.tokenizer.reopen_indent_level()
            {
                // The block's level sat between two known indents, so its
                // `Indent` was never emitted; re-open it directly.
                input.cursor.peek()?.span.start
            } else if input.sass_pending_indents > 0 {
                // The statement's clause consumed this block's `Indent` as a
                // line continuation (`@each $a in\n  b, c\n  .x\n    ...`);
                // enter the block "virtually" at that depth.
                input.sass_pending_indents -= 1;
                input.cursor.peek()?.span.start
            } else {
                let offset = input.cursor.peek()?.span.start;
                return Ok(SimpleBlock {
                    statements: input.vec(),
                    span: Span { start: offset, end: offset },
                });
            }
        } else {
            input.cursor.expect_l_brace()?.1.start
        };

        let statements = input.parse_statements(/* is_top_level */ false)?;

        // CSS Syntax: EOF closes all open constructs (a parse error, but the
        // tree is valid — browsers accept unclosed blocks at EOF). The
        // dialects' reference compilers reject them. Recovery is unchanged; the
        // parse error is surfaced via `recoverable_errors` so downstream
        // consumers can tell it apart from a properly closed block.
        if input.syntax == Syntax::Css && matches!(input.cursor.peek()?.token, Token::Eof(..)) {
            let end = input.cursor.peek()?.span.start;
            input
                .recoverable_errors
                .push(Error { kind: ErrorKind::EofInBlock, span: Span { start, end: start + 1 } });
            return Ok(SimpleBlock { statements, span: Span { start, end } });
        }

        if is_sass {
            match input.cursor.bump()? {
                TokenWithSpan { token: Token::Dedent(..) | Token::Eof(..), span } => {
                    let end = statements.last().map_or(span.start, |last| last.span().end);
                    Ok(SimpleBlock { statements, span: Span { start, end } })
                }
                TokenWithSpan { span, .. } => {
                    Err(Error { kind: ErrorKind::ExpectDedentOrEof, span })
                }
            }
        } else {
            let end = input.cursor.expect_r_brace()?.1.end;
            Ok(SimpleBlock { statements, span: Span { start, end } })
        }
    }
}

// https://drafts.csswg.org/css-syntax-3/#parse-a-stylesheet
//
// <stylesheet> = <rule-list>
impl<'a> Parse<'a> for Stylesheet<'a> {
    fn parse(input: &mut Parser<'a>) -> PResult<Self> {
        let statements = input.parse_statements(/* is_top_level */ true)?;
        input.cursor.expect_eof()?;
        Ok(Stylesheet { statements, span: Span { start: 0, end: input.source.len() } })
    }
}

impl<'a> Parser<'a> {
    /// `<declaration-value>` consumed as raw tokens (CSS Syntax "preserved
    /// tokens"), balancing `()`/`[]`/`{}` pairs, until a top-level `;`, an
    /// unbalanced closer, or a statement boundary. Used for custom-property
    /// values and as the fallback for CSS values the typed grammar rejects.
    ///
    /// <https://drafts.csswg.org/css-syntax-3/#typedef-declaration-value>
    ///
    /// `stop_at_top_level_brace` implements the CSS Nesting disambiguation: a
    /// `{` at the top level of a normal declaration's value means the whole
    /// construct is really a qualified rule, so the value must end there.
    /// Custom properties are exempt (`--foo: {a:b}` is a valid value).
    pub(super) fn parse_declaration_value_tokens(
        &mut self,
        stop_at_top_level_brace: bool,
    ) -> PResult<oxc_allocator::Vec<'a, ComponentValue<'a>>> {
        let mut values = self.vec_with_capacity(3);
        let mut pairs = Vec::with_capacity(1);
        // Span of the outermost currently-open pair (kept in sync with `pairs`
        // going empty↔non-empty), so the EOF parse error can point at the
        // opener like `SimpleBlock` does, not at the end of file.
        let mut outermost_pair_span: Option<Span> = None;
        loop {
            match &self.cursor.peek()?.token {
                Token::Dedent(..) | Token::Linebreak(..) => break,
                // CSS Syntax: EOF closes any still-open `(`/`[`/`{` group; recovery
                // is unchanged, but record the parse error so downstream consumers
                // can tell it apart from a balanced value. Report the outermost
                // unclosed opener; a raw-value `{` (e.g. `--x: {` — legal in custom
                // properties) is a block, not a paren.
                Token::Eof(..) => {
                    if let (Some(pair), Some(span)) = (pairs.first(), outermost_pair_span) {
                        let kind = match pair {
                            crate::util::PairedToken::Brace => ErrorKind::EofInBlock,
                            _ => ErrorKind::UnclosedParen,
                        };
                        self.recoverable_errors.push(Error { kind, span });
                    }
                    break;
                }
                Token::Semicolon(..) if pairs.is_empty() => {
                    break;
                }
                Token::LBrace(..) if stop_at_top_level_brace && pairs.is_empty() => {
                    break;
                }
                // An unterminated string survives as a preserved token (a parse
                // error kept verbatim; CSS Syntax §4.3.5). The tokenizer emits a
                // `BadStr` for both recoverable forms; recover the spec's split
                // from where the string stopped — at EOF it is a `<string-token>`
                // (canonically closable by appending the quote), at a newline a
                // `<bad-string-token>`.
                Token::BadStr(..) => {
                    let span = self.cursor.peek()?.span;
                    let kind = if span.end == self.source.len() {
                        ErrorKind::UnterminatedString
                    } else {
                        ErrorKind::BadString
                    };
                    self.recoverable_errors.push(Error { kind, span });
                }
                // An interpolated string (e.g. `'#{$expr}'` inside
                // `filter: progid:...`) must be parsed structurally:
                // the tokenizer needs `scan_string_template` to resume
                // the string after each `#{...}`, so consuming its
                // tokens as a plain stream would mis-lex the rest.
                Token::StrTemplate(..) => {
                    values.push(ComponentValue::InterpolableStr(self.parse()?));
                    continue;
                }
                token => {
                    let was_empty = pairs.is_empty();
                    if !crate::util::track_paired_token(token, &mut pairs) {
                        break;
                    }
                    if was_empty && !pairs.is_empty() {
                        outermost_pair_span = Some(self.cursor.peek()?.span);
                    }
                }
            }
            values.push(ComponentValue::TokenWithSpan(self.cursor.bump()?));
        }
        Ok(values)
    }

    // The typed form of `<declaration-value>`: a list of `<component-value>` up to
    // the declaration terminator (`;`, `!`, `}`, or a statement boundary).
    pub(super) fn parse_declaration_value(
        &mut self,
    ) -> PResult<oxc_allocator::Vec<'a, ComponentValue<'a>>> {
        let mut values = self.vec_with_capacity(3);
        loop {
            match &self.cursor.peek()?.token {
                Token::RBrace(..)
                | Token::RParen(..)
                | Token::Semicolon(..)
                | Token::Dedent(..)
                | Token::Linebreak(..)
                | Token::Exclamation(..)
                | Token::Eof(..) => break,
                _ => {
                    let value = self.parse::<ComponentValue>()?;
                    match &value {
                        ComponentValue::SassNestingDeclaration(..)
                            if matches!(self.syntax, Syntax::Scss | Syntax::Sass) =>
                        {
                            values.push(value);
                            break;
                        }
                        _ => values.push(value),
                    }
                }
            }
        }
        Ok(values)
    }

    /// In a `@keyframes` body, an ident may start a keyframe block (`from {`)
    /// or — in real-world code — a plain declaration (`blah: blee;`); dart-sass
    /// accepts both. Returns the statement and whether it opened a block.
    fn parse_keyframe_block_or_declaration(&mut self) -> PResult<(Statement<'a>, bool)> {
        if let Ok(block) = self.try_parse(KeyframeBlock::parse) {
            Ok((Statement::KeyframeBlock(block), true))
        } else {
            match self.parse_statement_declaration() {
                Ok(decl) => Ok((Statement::Declaration(decl), false)),
                Err(error_decl) => {
                    // postcss accepts the declaration-shaped rule inside `@keyframes` too
                    if let Some(rule) = self.try_declaration_shaped_rule(&error_decl) {
                        return Ok((Statement::UnknownQualifiedRule(rule), true));
                    }
                    Err(error_decl)
                }
            }
        }
    }

    /// A declaration in statement position.
    /// CSS snapshots the statement start so `try_declaration_shaped_rule` can re-consume it;
    /// dialects have no fallback, and an unrecovered Err aborts the parse, so no snapshot.
    fn parse_statement_declaration(&mut self) -> PResult<Declaration<'a>> {
        if self.syntax == Syntax::Css {
            self.try_parse(Parser::parse_style_rule_declaration)
        } else {
            self.parse_style_rule_declaration()
        }
    }

    /// The §5.5.5 re-consume (see `UnknownQualifiedRule`), CSS only: dialects
    /// keep their reference compilers' strictness (Scss types the shape as
    /// nested properties; less.js rejects it).
    fn try_declaration_shaped_rule(
        &mut self,
        error_decl: &Error,
    ) -> Option<UnknownQualifiedRule<'a>> {
        if !matches!(error_decl.kind, ErrorKind::BlockInDeclarationValue)
            || self.syntax != Syntax::Css
        {
            return None;
        }
        self.try_parse(UnknownQualifiedRule::parse).ok()
    }

    /// The CSS Nesting `<style-block>` ambiguity: parse a qualified rule, falling
    /// back to a declaration when the `foo: bar` vs `foo { }` prelude is
    /// ambiguous. Returns the statement and whether it opened a block (for the
    /// caller's `is_block_element`).
    ///
    /// <https://drafts.csswg.org/css-nesting-1/#syntax>
    fn parse_rule_or_declaration(&mut self, is_top_level: bool) -> PResult<(Statement<'a>, bool)> {
        match self.try_parse(QualifiedRule::parse) {
            Ok(rule) => Ok((Statement::QualifiedRule(rule), true)),
            Err(error_rule) => match self.parse_statement_declaration() {
                Ok(decl) => {
                    // Only Scss/Sass produce `SassNestingDeclaration`; in CSS this is
                    // always `false`, matching the previous per-syntax behavior.
                    let is_block_element = matches!(
                        decl.value.last(),
                        Some(ComponentValue::SassNestingDeclaration(..))
                    );
                    if is_top_level {
                        self.recoverable_errors
                            .push(Error { kind: ErrorKind::TopLevelDeclaration, span: decl.span });
                    }
                    Ok((Statement::Declaration(decl), is_block_element))
                }
                Err(error_decl) => {
                    if let Some(rule) = self.try_declaration_shaped_rule(&error_decl) {
                        return Ok((Statement::UnknownQualifiedRule(rule), true));
                    }
                    Err(if is_top_level { error_rule } else { error_decl })
                }
            },
        }
    }

    /// Parse a declaration that is a statement in a style-rule block, enabling the
    /// IE `*color` hack (see `ParserState::allow_ie_star_hack`). Feature-query
    /// declarations (`@supports`, `@container style()`, `@import supports()`) call
    /// `Declaration::parse` directly and so never enable it.
    fn parse_style_rule_declaration(&mut self) -> PResult<Declaration<'a>> {
        self.with_state(ParserState { allow_ie_star_hack: true, ..self.state.clone() }).parse()
    }

    // Block contents: a mix of declarations, nested style rules and at-rules
    // (CSS Syntax `<block-contents>`; `is_top_level` selects the `<stylesheet>`
    // rule-list, which has no declarations).
    // https://drafts.csswg.org/css-syntax-3/#consume-block-contents
    fn parse_statements(
        &mut self,
        is_top_level: bool,
    ) -> PResult<oxc_allocator::Vec<'a, Statement<'a>>> {
        let mut statements = self.vec_with_capacity(1);
        loop {
            // Set true for braced blocks AND `${}` placeholder statements: both
            // make the trailing terminator optional. A placeholder substitutes a
            // whole statement/declaration and, like postcss, needs no `;`, so the
            // next statement may follow directly (`${mixin}\n@media {...}`,
            // `${a} ${b}`, `${foo}: ${bar}`).
            let mut is_block_element = false;
            let TokenWithSpan { token, span } = self.cursor.peek()?;
            match token {
                Token::Ident(..) | Token::HashLBrace(..) | Token::AtLBraceVar(..) => {
                    match self.syntax {
                        Syntax::Css => {
                            if self.state.in_keyframes_at_rule {
                                let (stmt, is_block) =
                                    self.parse_keyframe_block_or_declaration()?;
                                is_block_element = is_block;
                                statements.push(stmt);
                            } else {
                                let (stmt, is_block) =
                                    self.parse_rule_or_declaration(is_top_level)?;
                                is_block_element = is_block;
                                statements.push(stmt);
                            }
                        }
                        Syntax::Scss | Syntax::Sass => {
                            if let Ok(sass_var_decl) =
                                self.try_parse(SassVariableDeclaration::parse)
                            {
                                statements.push(Statement::SassVariableDeclaration(
                                    self.alloc(sass_var_decl),
                                ));
                            } else if self.state.in_keyframes_at_rule {
                                let (stmt, is_block) =
                                    self.parse_keyframe_block_or_declaration()?;
                                is_block_element = is_block;
                                statements.push(stmt);
                            } else {
                                let (stmt, is_block) =
                                    self.parse_rule_or_declaration(is_top_level)?;
                                is_block_element = is_block;
                                statements.push(stmt);
                            }
                        }
                        Syntax::Less => {
                            if let Ok(stmt) = self.try_parse(Parser::parse_less_qualified_rule) {
                                statements.push(stmt);
                                is_block_element = true;
                            } else if let Ok(decl) =
                                // less.js parses root-level declarations and
                                // only rejects them at eval time.
                                self.try_parse(Declaration::parse)
                            {
                                statements.push(Statement::Declaration(decl));
                            } else if self.state.in_keyframes_at_rule {
                                statements.push(Statement::KeyframeBlock(self.parse()?));
                                is_block_element = true;
                            } else {
                                let fn_call = self.parse::<Function>()?;
                                is_block_element = matches!(
                                    fn_call.args.last(),
                                    Some(ComponentValue::LessDetachedRuleset(..))
                                );
                                statements.push(Statement::LessFunctionCall(fn_call));
                            }
                        }
                    }
                }
                // `5:-` — less.js's ruleProperty regex (`[_a-zA-Z0-9-]+`)
                // allows digit-only declaration names
                Token::Number(..)
                    if self.syntax == Syntax::Less
                        && !is_top_level
                        && self.source.as_bytes().get(span.end) == Some(&b':') =>
                {
                    let decl = self.parse_style_rule_declaration()?;
                    statements.push(Statement::Declaration(decl));
                }
                // `.3D(...)` — less.js allows digit-led mixin names, which
                // arrive as one <dimension-token>; they behave exactly like
                // `.foo` (`.3D ()`, `.3D;`), so only the leading `.` matters
                Token::Dot(..) | Token::Hash(..) | Token::Dimension(..)
                    if self.syntax == Syntax::Less
                        && (!matches!(token, Token::Dimension(..))
                            || self.source.as_bytes().get(span.start) == Some(&b'.')) =>
                {
                    let stmt = if let Ok(stmt) = self.try_parse(Parser::parse_less_qualified_rule) {
                        is_block_element = true;
                        stmt
                    } else if let Ok(mixin_def) = self.try_parse(LessMixinDefinition::parse) {
                        is_block_element = true;
                        Statement::LessMixinDefinition(self.alloc(mixin_def))
                    } else {
                        self.parse().map(Statement::LessMixinCall)?
                    };
                    statements.push(stmt);
                }
                Token::Dot(..) | Token::Hash(..) if !self.state.in_keyframes_at_rule => {
                    if self.syntax == Syntax::Css {
                        let (stmt, is_block) = self.parse_rule_or_declaration(is_top_level)?;
                        is_block_element = is_block;
                        statements.push(stmt);
                    } else {
                        statements.push(Statement::QualifiedRule(self.parse()?));
                        is_block_element = true;
                    }
                }
                Token::Ampersand(..)
                | Token::LBracket(..)
                | Token::Colon(..)
                | Token::ColonColon(..)
                | Token::Asterisk(..)
                | Token::Bar(..)
                | Token::NumberSign(..)
                    if !self.state.in_keyframes_at_rule =>
                {
                    if matches!(self.cursor.peek()?.token, Token::Asterisk(..)) {
                        // `*color: red` / `*zoom: 1` (an IE<=7 hack) looks like a `*`
                        // universal selector but is a declaration; try the rule, then
                        // fall back to a declaration. (A `*` never starts a
                        // `LessExtendRule`, so this can precede the Less split.)
                        if self.syntax == Syntax::Less {
                            match self.try_parse(Parser::parse_less_qualified_rule) {
                                Ok(stmt) => {
                                    statements.push(stmt);
                                    is_block_element = true;
                                }
                                // Less refuses declarations at the top level, like the
                                // ident-led path; keep root-level `*zoom: 1` an error.
                                Err(rule_err) if is_top_level => return Err(rule_err),
                                Err(_) => {
                                    let decl = self.parse_style_rule_declaration()?;
                                    statements.push(Statement::Declaration(decl));
                                }
                            }
                        } else {
                            let (stmt, is_block) = self.parse_rule_or_declaration(is_top_level)?;
                            is_block_element = is_block;
                            statements.push(stmt);
                        }
                    } else if self.syntax == Syntax::Less {
                        if let Ok(extend_rule) = self.try_parse(LessExtendRule::parse) {
                            statements.push(Statement::LessExtendRule(extend_rule));
                        } else {
                            statements.push(self.parse_less_qualified_rule()?);
                            is_block_element = true;
                        }
                    } else if self.syntax == Syntax::Css
                        && matches!(self.cursor.peek()?.token, Token::Colon(..))
                    {
                        let (stmt, is_block) = self.parse_rule_or_declaration(is_top_level)?;
                        is_block_element = is_block;
                        statements.push(stmt);
                    } else {
                        statements.push(Statement::QualifiedRule(self.parse()?));
                        is_block_element = true;
                    }
                }
                Token::AtKeyword(..) => match self.syntax {
                    Syntax::Css => {
                        let at_rule = self.parse::<AtRule>()?;
                        is_block_element = at_rule.block.is_some();
                        statements.push(Statement::AtRule(at_rule));
                    }
                    Syntax::Scss | Syntax::Sass => {
                        let at_keyword_name =
                            self.cursor.peek()?.at_keyword(self.source).unwrap().ident.name();
                        match &*at_keyword_name {
                            "if" => {
                                let sass_if_at_rule = self.parse()?;
                                statements
                                    .push(Statement::SassIfAtRule(self.alloc(sass_if_at_rule)));
                                is_block_element = true;
                            }
                            "else" => {
                                return Err(Error {
                                    kind: ErrorKind::UnexpectedSassElseAtRule,
                                    span: self.cursor.bump()?.span,
                                });
                            }
                            _ => {
                                let at_rule = self.parse::<AtRule>()?;
                                is_block_element = at_rule.block.is_some();
                                statements.push(Statement::AtRule(at_rule));
                            }
                        }
                    }
                    Syntax::Less => {
                        if let Ok(less_variable_declaration) =
                            self.try_parse(LessVariableDeclaration::parse)
                        {
                            is_block_element = matches!(
                                less_variable_declaration.value,
                                ComponentValue::LessDetachedRuleset(..)
                            );
                            statements.push(Statement::LessVariableDeclaration(
                                self.alloc(less_variable_declaration),
                            ));
                        } else if let Ok(variable_call) = self.try_parse(LessVariableCall::parse) {
                            statements.push(Statement::LessVariableCall(variable_call));
                        } else {
                            let at_rule = self.parse::<AtRule>()?;
                            is_block_element = at_rule.block.is_some();
                            statements.push(Statement::AtRule(at_rule));
                        }
                    }
                },
                Token::Placeholder(..) => {
                    // A placeholder may start a qualified rule (a substituted
                    // selector, e.g. CSS-in-JS `${Component} { ... }`) or stand
                    // alone as a statement (e.g. `` `PLACEHOLDER-0`; ``).
                    //
                    // A placeholder-led selector must not absorb across a newline:
                    // prettier keeps `${mixin}` on its own line and the following
                    // selector as a separate rule (`${mixin}\n& > .x {}` is two
                    // statements, not one). So only attempt the rule when the block
                    // `{` is reachable without an intervening newline-then-selector.
                    //
                    // A placeholder may also be a declaration property name
                    // (`${foo}: ${bar}`), so try a declaration before falling back
                    // to a bare placeholder statement. Same-line only: the `:` of
                    // a rule on the next line (`${mixin}\n:hover { ... }`) must
                    // not be absorbed as a declaration colon — like the qualified
                    // rule check above, a newline ends what the placeholder can own.
                    let ph_end = self.cursor.peek()?.span.end;
                    if self.placeholder_starts_qualified_rule(ph_end)
                        && let Ok(rule) = self.try_parse(QualifiedRule::parse)
                    {
                        statements.push(Statement::QualifiedRule(rule));
                        is_block_element = true;
                    } else if self.placeholder_starts_declaration(ph_end)
                        && let Ok(declaration) = self.try_parse(Declaration::parse)
                    {
                        // Reached only via the placeholder token above, so this
                        // is the `${foo}: ${bar}` form (placeholder property name).
                        statements.push(Statement::Declaration(declaration));
                        is_block_element = true;
                    } else {
                        let (placeholder, span) = self.cursor.expect_placeholder()?;
                        statements.push(Statement::Placeholder((placeholder, span).into()));
                        is_block_element = true;
                    }
                }
                // Css too: postcss-extend-rule's `%thick-border {}`
                // (see the placeholder arm in `SimpleSelector`'s parser).
                Token::Percent(..)
                    if matches!(self.syntax, Syntax::Scss | Syntax::Sass | Syntax::Css) =>
                {
                    statements.push(Statement::QualifiedRule(self.parse()?));
                    is_block_element = true;
                }
                Token::DollarVar(..) if matches!(self.syntax, Syntax::Scss | Syntax::Sass) => {
                    let declaration = self.parse()?;
                    statements.push(Statement::SassVariableDeclaration(self.alloc(declaration)));
                }
                Token::DollarVar(..)
                    if self.syntax == Syntax::Css && self.options.allow_postcss_simple_vars =>
                {
                    let declaration = self.parse()?;
                    statements
                        .push(Statement::PostcssSimpleVarDeclaration(self.alloc(declaration)));
                }
                // Indented-syntax shorthands: `=name` defines a mixin
                // (`@mixin name`) and `+name` includes one (`@include name`).
                // A spaced `+ b` stays a sibling-combinator selector: `+` is
                // an include only when glued to an identifier.
                Token::Equal(..) if self.syntax == Syntax::Sass => {
                    let eq_span = self.cursor.bump()?.span;
                    self.eat_sass_line_continuation()?;
                    let prelude = self.parse::<SassMixin>()?;
                    let block = self
                        .with_state(ParserState {
                            sass_ctx: self.state.sass_ctx
                                | super::state::SASS_CTX_ALLOW_KEYFRAME_BLOCK,
                            ..self.state.clone()
                        })
                        .parse::<SimpleBlock>()?;
                    let span = Span { start: eq_span.start, end: block.span.end };
                    statements.push(Statement::AtRule(AtRule {
                        name: Ident { name: "mixin", raw: "=", span: eq_span },
                        prelude: Some(AtRulePrelude::SassMixin(self.alloc(prelude))),
                        block: Some(block),
                        span,
                    }));
                    is_block_element = true;
                }
                Token::Plus(..)
                    if self.syntax == Syntax::Sass
                        && crate::tokenizer::ident_starts_at(self.source, span.end) =>
                {
                    let plus_span = self.cursor.bump()?.span;
                    let prelude = self.parse::<SassInclude>()?;
                    let block = if matches!(
                        self.cursor.peek()?.token,
                        Token::LBrace(..) | Token::Indent(..)
                    ) {
                        Some(
                            self.with_state(ParserState {
                                sass_ctx: self.state.sass_ctx
                                    | super::state::SASS_CTX_ALLOW_KEYFRAME_BLOCK,
                                ..self.state.clone()
                            })
                            .parse::<SimpleBlock>()?,
                        )
                    } else {
                        None
                    };
                    let end = block.as_ref().map_or(prelude.span.end, |block| block.span.end);
                    let span = Span { start: plus_span.start, end };
                    is_block_element = block.is_some();
                    statements.push(Statement::AtRule(AtRule {
                        name: Ident { name: "include", raw: "+", span: plus_span },
                        prelude: Some(AtRulePrelude::SassInclude(self.alloc(prelude))),
                        block,
                        span,
                    }));
                }
                Token::GreaterThan(..) | Token::Plus(..) | Token::Tilde(..) | Token::BarBar(..) => {
                    if self.syntax == Syntax::Less {
                        statements.push(self.parse_less_qualified_rule()?);
                    } else {
                        statements.push(Statement::QualifiedRule(self.parse()?));
                    }
                    is_block_element = true;
                }
                Token::DollarLBraceVar(..) if self.syntax == Syntax::Less => {
                    statements.push(self.parse().map(Statement::Declaration)?);
                }
                Token::Cdo(..) | Token::Cdc(..) => {
                    self.cursor.bump()?;
                    continue;
                }
                Token::At(..) if matches!(self.syntax, Syntax::Scss | Syntax::Sass) => {
                    let unknown_sass_at_rule = self.parse::<UnknownSassAtRule>()?;
                    is_block_element = unknown_sass_at_rule.block.is_some();
                    statements.push(Statement::UnknownSassAtRule(self.alloc(unknown_sass_at_rule)));
                }
                Token::Percentage(..)
                    if self.state.in_keyframes_at_rule
                        || self.state.sass_ctx & super::state::SASS_CTX_ALLOW_KEYFRAME_BLOCK
                            != 0
                        || self.state.less_ctx & super::state::LESS_CTX_ALLOW_KEYFRAME_BLOCK
                            != 0 =>
                {
                    statements.push(Statement::KeyframeBlock(self.parse()?));
                    is_block_element = true;
                }
                Token::RBrace(..) | Token::Eof(..) | Token::Dedent(..) => break,
                Token::Semicolon(..) | Token::Linebreak(..) => {
                    self.cursor.bump()?;
                    continue;
                }
                Token::LBrace(..) if self.syntax == Syntax::Css => {
                    // An empty selector (`{}`): postcss parses it as a qualified rule
                    // with no selector, so build one with an empty selector list.
                    let start = span.start;
                    let block = self.parse::<SimpleBlock>()?;
                    let selector = SelectorList {
                        selectors: self.vec(),
                        comma_spans: self.vec(),
                        span: Span { start, end: start },
                    };
                    let span = Span { start, end: block.span.end };
                    statements.push(Statement::QualifiedRule(QualifiedRule {
                        selector,
                        block,
                        span,
                    }));
                    is_block_element = true;
                }
                _ => {
                    return Err(Error {
                        kind: if self.state.in_keyframes_at_rule {
                            ErrorKind::ExpectKeyframeBlock
                        } else {
                            ErrorKind::ExpectRule
                        },
                        span: *span,
                    });
                }
            };
            // Drain continuation indents that never became a block (e.g.
            // `$a\n  : b` — the deeper line belonged to the statement's own
            // clause, so its matching `Dedent` has no block to close). A
            // drained `Dedent` is itself a line boundary, so the statement
            // separator is already satisfied.
            if self.drain_sass_pending_dedents()? {
                continue;
            }
            match &self.cursor.peek()?.token {
                Token::RBrace(..) | Token::Eof(..) | Token::Dedent(..) => break,
                _ => {
                    if self.syntax == Syntax::Sass {
                        // The indented syntax also accepts `;` as a statement
                        // terminator/separator (`a; b`), like a newline.
                        if is_block_element {
                            if self.cursor.eat_semicolon()?.is_none() {
                                self.cursor.eat_linebreak()?;
                            }
                        } else if self.cursor.eat_semicolon()?.is_none() {
                            self.cursor.expect_linebreak()?;
                        }
                    } else if is_block_element {
                        self.cursor.eat_semicolon()?;
                    } else {
                        self.cursor.expect_semicolon()?;
                    }
                }
            }
        }
        Ok(statements)
    }

    /// Whether a statement-position `${}` placeholder (ending at byte `from`)
    /// should be offered to `QualifiedRule::parse`. The css-in-js rule the parser
    /// can't see on its own, matching prettier:
    /// - a bare `{` after the placeholder IS absorbed — the placeholder is the
    ///   selector for that block (`${mixin}\n{ color: red }` is one rule; a bare
    ///   `{...}` is meaningless without a selector, so this is the only valid read)
    /// - a placeholder separated by whitespace from what follows, then a newline,
    ///   then selector content = a separate rule (`${mixin}\n& > .x {}` and
    ///   `${a} ${b}\nhtml {}` are two statements, not one — spaced placeholders
    ///   are typically mixin invocations, not selector pieces)
    /// - but a placeholder IMMEDIATELY glued to non-whitespace (e.g. `${p}:hover`
    ///   or `${p},`) is a compound-selector piece, so a multi-line selector list
    ///   (`${p}:hover &,\n${q}:focus &, { ... }`) is one rule — keep scanning for `{` across newlines.
    ///
    /// The real grammar (strings, comments, `#{...}` interpolations, validity) is
    /// left to `QualifiedRule::parse`, which runs next and rolls back if this guess was wrong.
    /// Deliberately NOT a tokenizer: it never early-exits on `;`/`}`
    /// (those may sit inside an attribute string or comment),
    /// so it can't misclassify a same-line selector containing them.
    fn placeholder_starts_qualified_rule(&self, from: usize) -> bool {
        let bytes = &self.source.as_bytes()[from..];
        // Immediately-adjacent non-whitespace (`${p}:hover`, `${p},`) means the
        // placeholder is a compound-selector piece: only `{` matters from here, regardless of newlines.
        if bytes.first().is_some_and(|b| !b.is_ascii_whitespace()) {
            return bytes.contains(&b'{');
        }
        // Otherwise the placeholder is separated by whitespace from what follows.
        // A `{` on the same line (whitespace-only prefix) still makes the
        // placeholder its selector; any non-whitespace after a newline starts a separate rule.
        let mut newline_seen = false;
        for &b in bytes {
            match b {
                b'{' => return true,
                // `\r`, `\r\n`, and `\n` all count as a newline (the tokenizer
                // treats a bare `\r` as a line break too).
                b'\n' | b'\r' => newline_seen = true,
                _ if b.is_ascii_whitespace() => {}
                _ if newline_seen => return false,
                _ => {}
            }
        }
        // No block at all -> a declaration or a bare placeholder, not a rule.
        false
    }

    /// Whether a statement-position `${}` placeholder (ending at byte `from`)
    /// should be offered to `Declaration::parse` as a property name
    /// (`${foo}: ${bar}`). Same-line only: a newline before the next
    /// non-whitespace means the placeholder stands alone and what follows is a
    /// separate statement (`${mixin}\n\n:disabled { ... }` must not become a
    /// declaration `${mixin}: disabled { ... }`). Whether a same-line follower
    /// actually forms a declaration is left to `Declaration::parse`, which
    /// rolls back if this guess was wrong.
    fn placeholder_starts_declaration(&self, from: usize) -> bool {
        for &b in &self.source.as_bytes()[from..] {
            match b {
                // A bare `\r` counts as a newline too, same as
                // `placeholder_starts_qualified_rule` above.
                b'\n' | b'\r' => return false,
                _ if b.is_ascii_whitespace() => {}
                _ => return true,
            }
        }
        false
    }
}