Skip to main content

rspack_lightningcss/
parser.rs

1use crate::declaration::{parse_declaration, DeclarationBlock, DeclarationList};
2use crate::error::{Error, ParserError, PrinterError};
3use crate::media_query::*;
4use crate::properties::custom::TokenList;
5use crate::rules::container::{ContainerCondition, ContainerName, ContainerRule};
6use crate::rules::font_feature_values::FontFeatureValuesRule;
7use crate::rules::font_palette_values::FontPaletteValuesRule;
8use crate::rules::layer::{LayerBlockRule, LayerStatementRule};
9use crate::rules::nesting::NestedDeclarationsRule;
10use crate::rules::position_try::PositionTryRule;
11use crate::rules::property::PropertyRule;
12use crate::rules::scope::ScopeRule;
13use crate::rules::starting_style::StartingStyleRule;
14use crate::rules::view_transition::ViewTransitionRule;
15use crate::rules::viewport::ViewportRule;
16
17use crate::properties::font::FamilyName;
18use crate::rules::{
19  counter_style::CounterStyleRule,
20  custom_media::CustomMediaRule,
21  document::MozDocumentRule,
22  font_face::{FontFaceDeclarationParser, FontFaceRule},
23  import::ImportRule,
24  keyframes::{KeyframeListParser, KeyframesName, KeyframesRule},
25  layer::LayerName,
26  media::MediaRule,
27  namespace::NamespaceRule,
28  nesting::NestingRule,
29  page::{PageRule, PageSelector},
30  style::StyleRule,
31  supports::{SupportsCondition, SupportsRule},
32  unknown::UnknownAtRule,
33  CssRule, CssRuleList, Location,
34};
35use crate::selector::{SelectorList, SelectorParser};
36use crate::traits::{Parse, ParseWithOptions};
37use crate::values::ident::{CustomIdent, DashedIdent};
38use crate::values::string::CowArcStr;
39use crate::vendor_prefix::VendorPrefix;
40#[cfg(feature = "visitor")]
41use crate::visitor::{Visit, VisitTypes, Visitor};
42use bitflags::bitflags;
43use cssparser::*;
44use rspack_lightningcss_selectors::parser::{NestingRequirement, ParseErrorRecovery};
45use std::sync::{Arc, RwLock};
46
47bitflags! {
48  /// Parser feature flags to enable.
49  #[derive(Clone, Debug, Default)]
50  #[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
51  pub struct ParserFlags: u8 {
52    /// Whether the enable the [CSS nesting](https://www.w3.org/TR/css-nesting-1/) draft syntax.
53    const NESTING = 1 << 0;
54    /// Whether to enable the [custom media](https://drafts.csswg.org/mediaqueries-5/#custom-mq) draft syntax.
55    const CUSTOM_MEDIA = 1 << 1;
56    /// Whether to enable the non-standard >>> and /deep/ selector combinators used by Vue and Angular.
57    const DEEP_SELECTOR_COMBINATOR = 1 << 2;
58    /// Whether to enable the [scroll navigation controls](https://drafts.csswg.org/css-overflow-5/#scroll-navigation-controls) draft syntax.
59    const SCROLL_NAVIGATION_CONTROLS = 1 << 3;
60  }
61}
62
63/// CSS parsing options.
64#[derive(Clone, Debug, Default)]
65pub struct ParserOptions<'i> {
66  /// Filename to use in error messages.
67  pub filename: String,
68  /// Whether the enable [CSS modules](https://github.com/css-modules/css-modules).
69  pub css_modules: Option<crate::css_modules::Config>,
70  /// The source index to assign to all parsed rules. Impacts the source map when
71  /// the style sheet is serialized.
72  pub source_index: u32,
73  /// Whether to ignore invalid rules and declarations rather than erroring.
74  pub error_recovery: bool,
75  /// A list that will be appended to when a warning occurs.
76  pub warnings: Option<Arc<RwLock<Vec<Error<ParserError<'i>>>>>>,
77  /// Feature flags to enable.
78  pub flags: ParserFlags,
79}
80
81#[cfg(feature = "into_owned")]
82impl<'i, 'any> rspack_lightningcss_static_self::IntoOwned<'any> for ParserOptions<'i> {
83  type Owned = ParserOptions<'any>;
84
85  fn into_owned(self) -> Self::Owned {
86    ParserOptions {
87      warnings: self.warnings.and_then(|warnings| {
88        if let Ok(errors) = warnings.read() {
89          Some(Arc::new(RwLock::new(
90            errors.iter().map(|e| e.clone().into_owned()).collect(),
91          )))
92        } else {
93          None
94        }
95      }),
96      ..self
97    }
98  }
99}
100
101impl<'i> ParserOptions<'i> {
102  #[inline]
103  pub(crate) fn warn(&self, warning: ParseError<'i, ParserError<'i>>) {
104    if let Some(warnings) = &self.warnings {
105      if let Ok(mut warnings) = warnings.write() {
106        warnings.push(Error::from(warning, self.filename.clone()));
107      }
108    }
109  }
110}
111
112#[derive(Clone, Default)]
113#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
114pub struct DefaultAtRuleParser;
115impl<'i> crate::traits::AtRuleParser<'i> for DefaultAtRuleParser {
116  type AtRule = DefaultAtRule;
117  type Error = ();
118  type Prelude = ();
119}
120
121#[derive(PartialEq, Clone, Debug)]
122#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
123#[cfg_attr(feature = "jsonschema", derive(schemars::JsonSchema))]
124pub struct DefaultAtRule;
125impl crate::traits::ToCss for DefaultAtRule {
126  fn to_css<PrinterT: crate::printer::PrinterTrait>(&self, _: &mut PrinterT) -> Result<(), PrinterError> {
127    Err(PrinterError {
128      kind: crate::error::PrinterErrorKind::FmtError,
129      loc: None,
130    })
131  }
132}
133
134#[cfg(feature = "into_owned")]
135impl<'any> rspack_lightningcss_static_self::IntoOwned<'any> for DefaultAtRule {
136  type Owned = Self;
137  fn into_owned(self) -> Self {
138    self
139  }
140}
141
142#[cfg(feature = "visitor")]
143#[cfg_attr(docsrs, doc(cfg(feature = "visitor")))]
144impl<'i, V: Visitor<'i, DefaultAtRule>> Visit<'i, DefaultAtRule, V> for DefaultAtRule {
145  const CHILD_TYPES: VisitTypes = VisitTypes::empty();
146  fn visit_children(&mut self, _: &mut V) -> Result<(), V::Error> {
147    Ok(())
148  }
149}
150
151#[derive(PartialEq, PartialOrd)]
152enum State {
153  Start = 1,
154  Layers = 2,
155  Imports = 3,
156  Namespaces = 4,
157  Body = 5,
158}
159
160/// The parser for the top-level rules in a stylesheet.
161pub struct TopLevelRuleParser<'a, 'i, T: crate::traits::AtRuleParser<'i>> {
162  pub options: &'a ParserOptions<'i>,
163  state: State,
164  at_rule_parser: &'a mut T,
165  rules: &'a mut CssRuleList<'i, T::AtRule>,
166}
167
168impl<'a, 'b, 'i, T: crate::traits::AtRuleParser<'i>> TopLevelRuleParser<'a, 'i, T> {
169  pub fn new(
170    options: &'a ParserOptions<'i>,
171    at_rule_parser: &'a mut T,
172    rules: &'a mut CssRuleList<'i, T::AtRule>,
173  ) -> Self {
174    TopLevelRuleParser {
175      options,
176      state: State::Start,
177      at_rule_parser,
178      rules,
179    }
180  }
181
182  pub fn nested<'x: 'b>(&'x mut self) -> NestedRuleParser<'x, 'i, T> {
183    NestedRuleParser {
184      options: &self.options,
185      at_rule_parser: self.at_rule_parser,
186      declarations: DeclarationList::new(),
187      important_declarations: DeclarationList::new(),
188      rules: &mut self.rules,
189      is_in_style_rule: false,
190      allow_declarations: false,
191    }
192  }
193}
194
195/// A rule prelude for at-rule with block.
196#[derive(Debug)]
197#[allow(dead_code)]
198pub enum AtRulePrelude<'i, T> {
199  /// A @font-face rule prelude.
200  FontFace,
201  /// A @font-feature-values rule prelude, with its FamilyName list.
202  FontFeatureValues(Vec<FamilyName<'i>>),
203  /// A @font-palette-values rule prelude, with its name.
204  FontPaletteValues(DashedIdent<'i>),
205  /// A @counter-style rule prelude, with its counter style name.
206  CounterStyle(CustomIdent<'i>),
207  /// A @media rule prelude, with its media queries.
208  Media(MediaList<'i>),
209  /// A @custom-media rule prelude.
210  CustomMedia(DashedIdent<'i>, MediaList<'i>),
211  /// An @supports rule, with its conditional
212  Supports(SupportsCondition<'i>),
213  /// A @viewport rule prelude.
214  Viewport(VendorPrefix),
215  /// A @keyframes rule, with its animation name and vendor prefix if exists.
216  Keyframes(KeyframesName<'i>, VendorPrefix),
217  /// A @page rule prelude.
218  Page(Vec<PageSelector<'i>>),
219  /// A @-moz-document rule.
220  MozDocument,
221  /// A @import rule prelude.
222  Import(
223    CowRcStr<'i>,
224    MediaList<'i>,
225    Option<SupportsCondition<'i>>,
226    Option<Option<LayerName<'i>>>,
227  ),
228  /// A @namespace rule prelude.
229  Namespace(Option<CowRcStr<'i>>, CowRcStr<'i>),
230  /// A @charset rule prelude.
231  Charset,
232  /// A @nest prelude.
233  Nest(SelectorList<'i>),
234  /// An @layer prelude.
235  Layer(Vec<LayerName<'i>>),
236  /// An @property prelude.
237  Property(DashedIdent<'i>),
238  /// An @position-try prelude.
239  PositionTry(DashedIdent<'i>),
240  /// A @container prelude.
241  /// Spec: https://drafts.csswg.org/css-conditional-5/#container-rule
242  /// @container [ <container-name>? <container-query>? ]!
243  Container(Option<ContainerName<'i>>, Option<ContainerCondition<'i>>),
244  /// A @starting-style prelude.
245  StartingStyle,
246  /// A @scope rule prelude.
247  Scope(Option<SelectorList<'i>>, Option<SelectorList<'i>>),
248  /// A @view-transition rule prelude.
249  ViewTransition,
250  /// An unknown prelude.
251  Unknown(CowArcStr<'i>, TokenList<'i>),
252  /// A custom prelude.
253  Custom(T),
254}
255
256impl<'i, T> AtRulePrelude<'i, T> {
257  // https://drafts.csswg.org/css-nesting/#conditionals
258  //     In addition to nested style rules, this specification allows nested group rules inside
259  //     of style rules: any at-rule whose body contains style rules can be nested inside of a
260  //     style rule as well.
261  fn allowed_in_style_rule(&self) -> bool {
262    match *self {
263      Self::Media(..)
264      | Self::Supports(..)
265      | Self::Container(..)
266      | Self::MozDocument
267      | Self::Layer(..)
268      | Self::StartingStyle
269      | Self::Scope(..)
270      | Self::Nest(..)
271      | Self::Unknown(..)
272      | Self::Custom(..) => true,
273
274      Self::Namespace(..)
275      | Self::FontFace
276      | Self::FontFeatureValues(..)
277      | Self::FontPaletteValues(..)
278      | Self::CounterStyle(..)
279      | Self::Keyframes(..)
280      | Self::Page(..)
281      | Self::Property(..)
282      | Self::PositionTry(..)
283      | Self::Import(..)
284      | Self::CustomMedia(..)
285      | Self::Viewport(..)
286      | Self::Charset
287      | Self::ViewTransition => false,
288    }
289  }
290}
291
292impl<'a, 'i, T: crate::traits::AtRuleParser<'i>> AtRuleParser<'i> for TopLevelRuleParser<'a, 'i, T> {
293  type Prelude = AtRulePrelude<'i, T::Prelude>;
294  type AtRule = ();
295  type Error = ParserError<'i>;
296
297  fn parse_prelude<'t>(
298    &mut self,
299    name: CowRcStr<'i>,
300    input: &mut Parser<'i, 't>,
301  ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
302    match_ignore_ascii_case! { &*name,
303      "import" => {
304        if self.state > State::Imports {
305          return Err(input.new_custom_error(ParserError::UnexpectedImportRule))
306        }
307
308        let url_string = input.expect_url_or_string()?.clone();
309
310        let layer = if input.try_parse(|input| input.expect_ident_matching("layer")).is_ok() {
311          Some(None)
312        } else if input.try_parse(|input| input.expect_function_matching("layer")).is_ok() {
313          let name = input.parse_nested_block(LayerName::parse).map(|name| Some(name))?;
314          Some(name)
315        } else {
316          None
317        };
318
319        let supports = if input.try_parse(|input| input.expect_function_matching("supports")).is_ok() {
320          Some(input.parse_nested_block(|input| {
321            input.try_parse(SupportsCondition::parse).or_else(|_| SupportsCondition::parse_declaration(input))
322          })?)
323        } else {
324          None
325        };
326        let media = MediaList::parse(input, &self.options)?;
327        return Ok(AtRulePrelude::Import(url_string, media, supports, layer));
328      },
329      "namespace" => {
330        if self.state > State::Namespaces {
331          return Err(input.new_custom_error(ParserError::UnexpectedNamespaceRule))
332        }
333
334        let prefix = input.try_parse(|input| input.expect_ident_cloned()).ok();
335        let namespace = input.expect_url_or_string()?;
336        let prelude = AtRulePrelude::Namespace(prefix, namespace);
337        return Ok(prelude);
338      },
339      "charset" => {
340        // @charset is removed by rust-cssparser if it’s the first rule in the stylesheet.
341        // Anything left is technically invalid, however, users often concatenate CSS files
342        // together, so we are more lenient and simply ignore @charset rules in the middle of a file.
343        input.expect_string()?;
344        return Ok(AtRulePrelude::Charset)
345      },
346      "custom-media" if self.options.flags.contains(ParserFlags::CUSTOM_MEDIA) => {
347        let name = DashedIdent::parse(input)?;
348        let media = MediaList::parse(input, &self.options)?;
349        return Ok(AtRulePrelude::CustomMedia(name, media))
350      },
351      _ => {}
352    }
353
354    AtRuleParser::parse_prelude(&mut self.nested(), name, input)
355  }
356
357  #[inline]
358  fn parse_block<'t>(
359    &mut self,
360    prelude: Self::Prelude,
361    start: &ParserState,
362    input: &mut Parser<'i, 't>,
363  ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> {
364    self.state = State::Body;
365    AtRuleParser::parse_block(&mut self.nested(), prelude, start, input)
366  }
367
368  #[inline]
369  fn rule_without_block(
370    &mut self,
371    prelude: AtRulePrelude<'i, T::Prelude>,
372    start: &ParserState,
373  ) -> Result<Self::AtRule, ()> {
374    let loc = start.source_location();
375    let loc = Location {
376      source_index: self.options.source_index,
377      line: loc.line,
378      column: loc.column,
379    };
380
381    match prelude {
382      AtRulePrelude::Import(url, media, supports, layer) => {
383        self.state = State::Imports;
384        self.rules.0.push(CssRule::Import(ImportRule {
385          url: url.into(),
386          layer,
387          supports,
388          media,
389          loc,
390        }));
391        Ok(())
392      }
393      AtRulePrelude::Namespace(prefix, url) => {
394        self.state = State::Namespaces;
395
396        self.rules.0.push(CssRule::Namespace(NamespaceRule {
397          prefix: prefix.map(|x| x.into()),
398          url: url.into(),
399          loc,
400        }));
401        Ok(())
402      }
403      AtRulePrelude::CustomMedia(name, query) => {
404        self.state = State::Body;
405        self.rules.0.push(CssRule::CustomMedia(CustomMediaRule { name, query, loc }));
406        Ok(())
407      }
408      AtRulePrelude::Layer(_) => {
409        // @layer statements are allowed before @import rules, but cannot be interleaved.
410        if self.state <= State::Layers {
411          self.state = State::Layers;
412        } else {
413          self.state = State::Body;
414        }
415        AtRuleParser::rule_without_block(&mut self.nested(), prelude, start)
416      }
417      AtRulePrelude::Charset => Ok(()),
418      AtRulePrelude::Unknown(name, prelude) => {
419        self.rules.0.push(CssRule::Unknown(UnknownAtRule {
420          name,
421          prelude,
422          block: None,
423          loc,
424        }));
425        Ok(())
426      }
427      AtRulePrelude::Custom(_) => {
428        self.state = State::Body;
429        AtRuleParser::rule_without_block(&mut self.nested(), prelude, start)
430      }
431      _ => Err(()),
432    }
433  }
434}
435
436impl<'a, 'i, T: crate::traits::AtRuleParser<'i>> QualifiedRuleParser<'i> for TopLevelRuleParser<'a, 'i, T> {
437  type Prelude = SelectorList<'i>;
438  type QualifiedRule = ();
439  type Error = ParserError<'i>;
440
441  #[inline]
442  fn parse_prelude<'t>(
443    &mut self,
444    input: &mut Parser<'i, 't>,
445  ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
446    self.state = State::Body;
447    QualifiedRuleParser::parse_prelude(&mut self.nested(), input)
448  }
449
450  #[inline]
451  fn parse_block<'t>(
452    &mut self,
453    prelude: Self::Prelude,
454    start: &ParserState,
455    input: &mut Parser<'i, 't>,
456  ) -> Result<Self::QualifiedRule, ParseError<'i, Self::Error>> {
457    QualifiedRuleParser::parse_block(&mut self.nested(), prelude, start, input)
458  }
459}
460
461pub struct NestedRuleParser<'a, 'i, T: crate::traits::AtRuleParser<'i>> {
462  pub options: &'a ParserOptions<'i>,
463  pub at_rule_parser: &'a mut T,
464  declarations: DeclarationList<'i>,
465  important_declarations: DeclarationList<'i>,
466  rules: &'a mut CssRuleList<'i, T::AtRule>,
467  is_in_style_rule: bool,
468  allow_declarations: bool,
469}
470
471impl<'a, 'b, 'i, T: crate::traits::AtRuleParser<'i>> NestedRuleParser<'a, 'i, T> {
472  pub fn parse_nested<'t>(
473    &mut self,
474    input: &mut Parser<'i, 't>,
475    is_style_rule: bool,
476  ) -> Result<(DeclarationBlock<'i>, CssRuleList<'i, T::AtRule>), ParseError<'i, ParserError<'i>>> {
477    let mut rules = CssRuleList(vec![]);
478    let mut nested_parser = NestedRuleParser {
479      options: self.options,
480      at_rule_parser: self.at_rule_parser,
481      declarations: DeclarationList::new(),
482      important_declarations: DeclarationList::new(),
483      rules: &mut rules,
484      is_in_style_rule: self.is_in_style_rule || is_style_rule,
485      allow_declarations: self.allow_declarations || self.is_in_style_rule || is_style_rule,
486    };
487
488    let parse_declarations = nested_parser.parse_declarations();
489    let mut errors = Vec::new();
490    let mut iter = RuleBodyParser::new(input, &mut nested_parser);
491    while let Some(result) = iter.next() {
492      match result {
493        Ok(()) => {}
494        Err((e, _)) => {
495          if parse_declarations {
496            iter.parser.declarations.clear();
497            iter.parser.important_declarations.clear();
498            errors.push(e);
499          } else {
500            if iter.parser.options.error_recovery {
501              iter.parser.options.warn(e);
502              continue;
503            }
504            return Err(e);
505          }
506        }
507      }
508    }
509
510    if parse_declarations {
511      if !errors.is_empty() {
512        if self.options.error_recovery {
513          for err in errors {
514            self.options.warn(err);
515          }
516        } else {
517          return Err(errors.remove(0));
518        }
519      }
520    }
521
522    Ok((
523      DeclarationBlock {
524        declarations: nested_parser.declarations,
525        important_declarations: nested_parser.important_declarations,
526      },
527      rules,
528    ))
529  }
530
531  fn parse_style_block<'t>(
532    &mut self,
533    input: &mut Parser<'i, 't>,
534  ) -> Result<CssRuleList<'i, T::AtRule>, ParseError<'i, ParserError<'i>>> {
535    let loc = input.current_source_location();
536    let loc = Location {
537      source_index: self.options.source_index,
538      line: loc.line,
539      column: loc.column,
540    };
541
542    // Declarations can be immediately within @media and @supports blocks that are nested within a parent style rule.
543    // These are wrapped in an (invisible) NestedDeclarationsRule.
544    let (declarations, mut rules) = self.parse_nested(input, false)?;
545
546    if declarations.len() > 0 {
547      rules.0.insert(
548        0,
549        CssRule::NestedDeclarations(NestedDeclarationsRule { declarations, loc }),
550      )
551    }
552
553    Ok(rules)
554  }
555
556  fn loc(&self, start: &ParserState) -> Location {
557    let loc = start.source_location();
558    Location {
559      source_index: self.options.source_index,
560      line: loc.line,
561      column: loc.column,
562    }
563  }
564}
565
566impl<'a, 'b, 'i, T: crate::traits::AtRuleParser<'i>> AtRuleParser<'i> for NestedRuleParser<'a, 'i, T> {
567  type Prelude = AtRulePrelude<'i, T::Prelude>;
568  type AtRule = ();
569  type Error = ParserError<'i>;
570
571  fn parse_prelude<'t>(
572    &mut self,
573    name: CowRcStr<'i>,
574    input: &mut Parser<'i, 't>,
575  ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
576    let result = match_ignore_ascii_case! { &*name,
577      "media" => {
578        let media = MediaList::parse(input, &self.options)?;
579        AtRulePrelude::Media(media)
580      },
581      "supports" => {
582        let cond = SupportsCondition::parse(input, )?;
583        AtRulePrelude::Supports(cond)
584      },
585      "font-face" => {
586        AtRulePrelude::FontFace
587      },
588      // "font-feature-values" => {
589      //     if !cfg!(feature = "gecko") {
590      //         // Support for this rule is not fully implemented in Servo yet.
591      //         return Err(input.new_custom_error(StyleParseErrorKind::UnsupportedAtRule(name.clone())))
592      //     }
593      //     let family_names = parse_family_name_list(self.context, input)?;
594      //     Ok(AtRuleType::WithBlock(AtRuleBlockPrelude::FontFeatureValues(family_names)))
595      // },
596      "font-feature-values" => {
597        let names = match Vec::<FamilyName>::parse(input) {
598          Ok(names) => names,
599          Err(e) => return Err(e)
600        };
601
602        AtRulePrelude::FontFeatureValues(names)
603      },
604      "font-palette-values" => {
605        let name = DashedIdent::parse(input)?;
606        AtRulePrelude::FontPaletteValues(name)
607      },
608      "counter-style" => {
609        let name = CustomIdent::parse(input)?;
610        AtRulePrelude::CounterStyle(name)
611      },
612      "viewport" | "-ms-viewport" => {
613        let prefix = if starts_with_ignore_ascii_case(&*name, "-ms") {
614          VendorPrefix::Ms
615        } else {
616          VendorPrefix::None
617        };
618        AtRulePrelude::Viewport(prefix)
619      },
620      "keyframes" | "-webkit-keyframes" | "-moz-keyframes" | "-o-keyframes" | "-ms-keyframes" => {
621        let prefix = if starts_with_ignore_ascii_case(&*name, "-webkit-") {
622          VendorPrefix::WebKit
623        } else if starts_with_ignore_ascii_case(&*name, "-moz-") {
624          VendorPrefix::Moz
625        } else if starts_with_ignore_ascii_case(&*name, "-o-") {
626          VendorPrefix::O
627        } else if starts_with_ignore_ascii_case(&*name, "-ms-") {
628          VendorPrefix::Ms
629        } else {
630          VendorPrefix::None
631        };
632
633        let name = input.try_parse(KeyframesName::parse)?;
634        AtRulePrelude::Keyframes(name, prefix)
635      },
636      "page" => {
637        let selectors = input.try_parse(|input| input.parse_comma_separated(PageSelector::parse)).unwrap_or_default();
638        AtRulePrelude::Page(selectors)
639      },
640      "-moz-document" => {
641        // Firefox only supports the url-prefix() function with no arguments as a legacy CSS hack.
642        // See https://css-tricks.com/snippets/css/css-hacks-targeting-firefox/
643        input.expect_function_matching("url-prefix")?;
644        input.parse_nested_block(|input| {
645          // Firefox also allows an empty string as an argument...
646          // https://github.com/mozilla/gecko-dev/blob/0077f2248712a1b45bf02f0f866449f663538164/servo/components/style/stylesheets/document_rule.rs#L303
647          let _ = input.try_parse(|input| -> Result<(), ParseError<'i, Self::Error>> {
648            let s = input.expect_string()?;
649            if !s.is_empty() {
650              return Err(input.new_custom_error(ParserError::InvalidValue))
651            }
652            Ok(())
653          });
654          input.expect_exhausted()?;
655          Ok(())
656        })?;
657
658        AtRulePrelude::MozDocument
659      },
660      "layer" => {
661        let names = match Vec::<LayerName>::parse(input) {
662          Ok(names) => names,
663          Err(ParseError { kind: ParseErrorKind::Basic(BasicParseErrorKind::EndOfInput), .. }) => Vec::new(),
664          Err(e) => return Err(e)
665        };
666        AtRulePrelude::Layer(names)
667      },
668      "container" => {
669        let name = input.try_parse(ContainerName::parse).ok();
670        match input.try_parse(|input| ContainerCondition::parse_with_options(input, &self.options)) {
671          Ok(condition) => AtRulePrelude::Container(name, Some(condition)),
672          Err(e) => {
673            if name.is_some() && input.is_exhausted() {
674              // name only, no condition - allowed by new syntax
675              AtRulePrelude::Container(name, None)
676            } else {
677              // condition parsing failed (e.g., empty brackets or invalid tokens)
678              return Err(e);
679            }
680          }
681        }
682      },
683      "starting-style" => {
684        AtRulePrelude::StartingStyle
685      },
686      "scope" => {
687        let selector_parser = SelectorParser {
688          is_nesting_allowed: true,
689          options: &self.options,
690        };
691
692        let scope_start = if input.try_parse(|input| input.expect_parenthesis_block()).is_ok() {
693          Some(input.parse_nested_block(|input| {
694            // https://drafts.csswg.org/css-cascade-6/#scoped-rules
695            // TODO: disallow pseudo elements?
696            SelectorList::parse_relative(&selector_parser, input, ParseErrorRecovery::IgnoreInvalidSelector, NestingRequirement::None)
697          })?)
698        } else {
699          None
700        };
701
702        let scope_end = if input.try_parse(|input| input.expect_ident_matching("to")).is_ok() {
703          input.expect_parenthesis_block()?;
704          Some(input.parse_nested_block(|input| {
705            SelectorList::parse_relative(&selector_parser, input, ParseErrorRecovery::IgnoreInvalidSelector, NestingRequirement::None)
706          })?)
707        } else {
708          None
709        };
710
711        AtRulePrelude::Scope(scope_start, scope_end)
712      },
713      "view-transition" => {
714        AtRulePrelude::ViewTransition
715      },
716      "nest" if self.is_in_style_rule => {
717        self.options.warn(input.new_custom_error(ParserError::DeprecatedNestRule));
718        let selector_parser = SelectorParser {
719          is_nesting_allowed: true,
720          options: &self.options,
721        };
722        let selectors = SelectorList::parse(&selector_parser, input, ParseErrorRecovery::DiscardList, NestingRequirement::Contained)?;
723        AtRulePrelude::Nest(selectors)
724      },
725
726      "value" if self.options.css_modules.is_some() => {
727        return Err(input.new_custom_error(ParserError::DeprecatedCssModulesValueRule));
728      },
729
730      "property" => {
731        let name = DashedIdent::parse(input)?;
732        return Ok(AtRulePrelude::Property(name))
733      },
734
735      "position-try" => {
736        let name = DashedIdent::parse(input)?;
737        return Ok(AtRulePrelude::PositionTry(name))
738      },
739
740      _ => parse_custom_at_rule_prelude(&name, input, self.options, self.at_rule_parser)?
741    };
742
743    if self.is_in_style_rule && !result.allowed_in_style_rule() {
744      return Err(input.new_error(BasicParseErrorKind::AtRuleInvalid(name.clone())));
745    }
746
747    Ok(result)
748  }
749
750  #[inline]
751  fn rule_without_block(
752    &mut self,
753    prelude: AtRulePrelude<'i, T::Prelude>,
754    start: &ParserState,
755  ) -> Result<Self::AtRule, ()> {
756    let loc = self.loc(start);
757    match prelude {
758      AtRulePrelude::Layer(names) => {
759        if self.is_in_style_rule || names.is_empty() {
760          return Err(());
761        }
762
763        self.rules.0.push(CssRule::LayerStatement(LayerStatementRule { names, loc }));
764        Ok(())
765      }
766      AtRulePrelude::Unknown(name, prelude) => {
767        self.rules.0.push(CssRule::Unknown(UnknownAtRule {
768          name,
769          prelude,
770          block: None,
771          loc,
772        }));
773        Ok(())
774      }
775      AtRulePrelude::Custom(prelude) => {
776        self.rules.0.push(parse_custom_at_rule_without_block(
777          prelude,
778          start,
779          self.options,
780          self.at_rule_parser,
781          self.is_in_style_rule,
782        )?);
783        Ok(())
784      }
785      _ => Err(()),
786    }
787  }
788
789  fn parse_block<'t>(
790    &mut self,
791    prelude: Self::Prelude,
792    start: &ParserState,
793    input: &mut Parser<'i, 't>,
794  ) -> Result<(), ParseError<'i, Self::Error>> {
795    let loc = self.loc(start);
796    match prelude {
797      AtRulePrelude::FontFace => {
798        let mut decl_parser = FontFaceDeclarationParser;
799        let mut parser = RuleBodyParser::new(input, &mut decl_parser);
800        let mut properties = vec![];
801        while let Some(decl) = parser.next() {
802          if let Ok(decl) = decl {
803            properties.push(decl);
804          }
805        }
806        self.rules.0.push(CssRule::FontFace(FontFaceRule { properties, loc }));
807        Ok(())
808      }
809      // AtRuleBlockPrelude::FontFeatureValues(family_names) => {
810      //     let context = ParserContext::new_with_rule_type(
811      //         self.context,
812      //         CssRuleType::FontFeatureValues,
813      //         self.namespaces,
814      //     );
815
816      //     Ok(CssRule::FontFeatureValues(Arc::new(self.shared_lock.wrap(
817      //         FontFeatureValuesRule::parse(
818      //             &context,
819      //             input,
820      //             family_names,
821      //             start.source_location(),
822      //         ),
823      //     ))))
824      // },
825      AtRulePrelude::FontPaletteValues(name) => {
826        let rule = FontPaletteValuesRule::parse(name, input, loc)?;
827        self.rules.0.push(CssRule::FontPaletteValues(rule));
828        Ok(())
829      }
830      AtRulePrelude::CounterStyle(name) => {
831        self.rules.0.push(CssRule::CounterStyle(CounterStyleRule {
832          name,
833          declarations: DeclarationBlock::parse(input, self.options)?,
834          loc,
835        }));
836        Ok(())
837      }
838      AtRulePrelude::Media(query) => {
839        let rules = self.parse_style_block(input)?;
840        self.rules.0.push(CssRule::Media(MediaRule { query, rules, loc }));
841        Ok(())
842      }
843      AtRulePrelude::Supports(condition) => {
844        let rules = self.parse_style_block(input)?;
845        self.rules.0.push(CssRule::Supports(SupportsRule { condition, rules, loc }));
846        Ok(())
847      }
848      AtRulePrelude::Container(name, condition) => {
849        let rules = self.parse_style_block(input)?;
850        self.rules.0.push(CssRule::Container(ContainerRule {
851          name,
852          condition,
853          rules,
854          loc,
855        }));
856        Ok(())
857      }
858      AtRulePrelude::Scope(scope_start, scope_end) => {
859        let rules = self.parse_style_block(input)?;
860        self.rules.0.push(CssRule::Scope(ScopeRule {
861          scope_start,
862          scope_end,
863          rules,
864          loc,
865        }));
866        Ok(())
867      }
868      AtRulePrelude::Viewport(vendor_prefix) => {
869        self.rules.0.push(CssRule::Viewport(ViewportRule {
870          vendor_prefix,
871          // TODO: parse viewport descriptors rather than properties
872          // https://drafts.csswg.org/css-device-adapt/#viewport-desc
873          declarations: DeclarationBlock::parse(input, self.options)?,
874          loc,
875        }));
876        Ok(())
877      }
878      AtRulePrelude::Keyframes(name, vendor_prefix) => {
879        let mut parser = KeyframeListParser;
880        let iter = RuleBodyParser::new(input, &mut parser);
881        self.rules.0.push(CssRule::Keyframes(KeyframesRule {
882          name,
883          keyframes: iter.filter_map(Result::ok).collect(),
884          vendor_prefix,
885          loc,
886        }));
887        Ok(())
888      }
889      AtRulePrelude::Page(selectors) => {
890        let rule = PageRule::parse(selectors, input, loc, self.options)?;
891        self.rules.0.push(CssRule::Page(rule));
892        Ok(())
893      }
894      AtRulePrelude::MozDocument => {
895        let rules = self.parse_style_block(input)?;
896        self.rules.0.push(CssRule::MozDocument(MozDocumentRule { rules, loc }));
897        Ok(())
898      }
899      AtRulePrelude::Layer(names) => {
900        let name = if names.is_empty() {
901          None
902        } else if names.len() == 1 {
903          names.into_iter().next()
904        } else {
905          return Err(input.new_error(BasicParseErrorKind::AtRuleBodyInvalid));
906        };
907
908        let rules = self.parse_style_block(input)?;
909        self.rules.0.push(CssRule::LayerBlock(LayerBlockRule { name, rules, loc }));
910        Ok(())
911      }
912      AtRulePrelude::Property(name) => {
913        self.rules.0.push(CssRule::Property(PropertyRule::parse(name, input, loc)?));
914        Ok(())
915      }
916      AtRulePrelude::PositionTry(name) => {
917        self.rules.0.push(CssRule::PositionTry(PositionTryRule {
918          name,
919          declarations: DeclarationBlock::parse(input, self.options)?,
920          loc,
921        }));
922        Ok(())
923      }
924      AtRulePrelude::Import(..)
925      | AtRulePrelude::Namespace(..)
926      | AtRulePrelude::CustomMedia(..)
927      | AtRulePrelude::Charset => {
928        // These rules don't have blocks.
929        Err(input.new_unexpected_token_error(Token::CurlyBracketBlock))
930      }
931      AtRulePrelude::StartingStyle => {
932        let rules = self.parse_style_block(input)?;
933        self.rules.0.push(CssRule::StartingStyle(StartingStyleRule { rules, loc }));
934        Ok(())
935      }
936      AtRulePrelude::ViewTransition => {
937        self
938          .rules
939          .0
940          .push(CssRule::ViewTransition(ViewTransitionRule::parse(input, loc)?));
941        Ok(())
942      }
943      AtRulePrelude::Nest(selectors) => {
944        let (declarations, rules) = self.parse_nested(input, true)?;
945        self.rules.0.push(CssRule::Nesting(NestingRule {
946          style: StyleRule {
947            selectors,
948            declarations,
949            vendor_prefix: VendorPrefix::empty(),
950            rules,
951            loc,
952          },
953          loc,
954        }));
955        Ok(())
956      }
957      AtRulePrelude::FontFeatureValues(family_names) => {
958        let rule = FontFeatureValuesRule::parse(family_names, input, loc, self.options)?;
959        self.rules.0.push(CssRule::FontFeatureValues(rule));
960        Ok(())
961      }
962      AtRulePrelude::Unknown(name, prelude) => {
963        self.rules.0.push(CssRule::Unknown(UnknownAtRule {
964          name,
965          prelude,
966          block: Some(TokenList::parse(input, &self.options, 0)?),
967          loc,
968        }));
969        Ok(())
970      }
971      AtRulePrelude::Custom(prelude) => {
972        self.rules.0.push(parse_custom_at_rule_body(
973          prelude,
974          input,
975          start,
976          self.options,
977          self.at_rule_parser,
978          self.is_in_style_rule,
979        )?);
980        Ok(())
981      }
982    }
983  }
984}
985
986impl<'a, 'b, 'i, T: crate::traits::AtRuleParser<'i>> QualifiedRuleParser<'i> for NestedRuleParser<'a, 'i, T> {
987  type Prelude = SelectorList<'i>;
988  type QualifiedRule = ();
989  type Error = ParserError<'i>;
990
991  fn parse_prelude<'t>(
992    &mut self,
993    input: &mut Parser<'i, 't>,
994  ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
995    let selector_parser = SelectorParser {
996      is_nesting_allowed: true,
997      options: &self.options,
998    };
999    if self.is_in_style_rule {
1000      SelectorList::parse_relative(
1001        &selector_parser,
1002        input,
1003        ParseErrorRecovery::DiscardList,
1004        NestingRequirement::Implicit,
1005      )
1006    } else {
1007      SelectorList::parse(
1008        &selector_parser,
1009        input,
1010        ParseErrorRecovery::DiscardList,
1011        NestingRequirement::None,
1012      )
1013    }
1014  }
1015
1016  fn parse_block<'t>(
1017    &mut self,
1018    selectors: Self::Prelude,
1019    start: &ParserState,
1020    input: &mut Parser<'i, 't>,
1021  ) -> Result<(), ParseError<'i, Self::Error>> {
1022    let loc = self.loc(start);
1023    let (declarations, rules) = self.parse_nested(input, true)?;
1024    self.rules.0.push(CssRule::Style(StyleRule {
1025      selectors,
1026      vendor_prefix: VendorPrefix::empty(),
1027      declarations,
1028      rules,
1029      loc,
1030    }));
1031    Ok(())
1032  }
1033}
1034
1035/// Parse a declaration within {} block: `color: blue`
1036impl<'a, 'i, T: crate::traits::AtRuleParser<'i>> cssparser::DeclarationParser<'i> for NestedRuleParser<'a, 'i, T> {
1037  type Declaration = ();
1038  type Error = ParserError<'i>;
1039
1040  fn parse_value<'t>(
1041    &mut self,
1042    name: CowRcStr<'i>,
1043    input: &mut cssparser::Parser<'i, 't>,
1044    _declaration_start: &ParserState,
1045  ) -> Result<Self::Declaration, cssparser::ParseError<'i, Self::Error>> {
1046    if self.rules.0.is_empty() {
1047      parse_declaration(
1048        name,
1049        input,
1050        &mut self.declarations,
1051        &mut self.important_declarations,
1052        &self.options,
1053      )
1054    } else if let Some(CssRule::NestedDeclarations(last)) = self.rules.0.last_mut() {
1055      parse_declaration(
1056        name,
1057        input,
1058        &mut last.declarations.declarations,
1059        &mut last.declarations.important_declarations,
1060        &self.options,
1061      )
1062    } else {
1063      let loc = self.loc(&input.state());
1064      let mut nested = NestedDeclarationsRule {
1065        declarations: DeclarationBlock::new(),
1066        loc,
1067      };
1068
1069      parse_declaration(
1070        name,
1071        input,
1072        &mut nested.declarations.declarations,
1073        &mut nested.declarations.important_declarations,
1074        &self.options,
1075      )?;
1076
1077      self.rules.0.push(CssRule::NestedDeclarations(nested));
1078      Ok(())
1079    }
1080  }
1081}
1082
1083impl<'a, 'b, 'i, T: crate::traits::AtRuleParser<'i>> RuleBodyItemParser<'i, (), ParserError<'i>>
1084  for NestedRuleParser<'a, 'i, T>
1085{
1086  fn parse_qualified(&self) -> bool {
1087    true
1088  }
1089
1090  fn parse_declarations(&self) -> bool {
1091    self.allow_declarations
1092  }
1093}
1094
1095fn parse_custom_at_rule_prelude<'i, 't, T: crate::traits::AtRuleParser<'i>>(
1096  name: &CowRcStr<'i>,
1097  input: &mut Parser<'i, 't>,
1098  options: &ParserOptions<'i>,
1099  at_rule_parser: &mut T,
1100) -> Result<AtRulePrelude<'i, T::Prelude>, ParseError<'i, ParserError<'i>>> {
1101  match at_rule_parser.parse_prelude(name.clone(), input, options) {
1102    Ok(prelude) => return Ok(AtRulePrelude::Custom(prelude)),
1103    Err(ParseError {
1104      kind: ParseErrorKind::Basic(BasicParseErrorKind::AtRuleInvalid(..)),
1105      ..
1106    }) => {}
1107    Err(err) => {
1108      return Err(match &err.kind {
1109        ParseErrorKind::Basic(kind) => ParseError {
1110          kind: ParseErrorKind::Basic(kind.clone()),
1111          location: err.location,
1112        },
1113        _ => input.new_custom_error(ParserError::AtRulePreludeInvalid),
1114      })
1115    }
1116  }
1117
1118  options.warn(input.new_error(BasicParseErrorKind::AtRuleInvalid(name.clone())));
1119  input.skip_whitespace();
1120  let tokens = TokenList::parse(input, &options, 0)?;
1121  Ok(AtRulePrelude::Unknown(name.into(), tokens))
1122}
1123
1124fn parse_custom_at_rule_body<'i, 't, T: crate::traits::AtRuleParser<'i>>(
1125  prelude: T::Prelude,
1126  input: &mut Parser<'i, 't>,
1127  start: &ParserState,
1128  options: &ParserOptions<'i>,
1129  at_rule_parser: &mut T,
1130  is_nested: bool,
1131) -> Result<CssRule<'i, T::AtRule>, ParseError<'i, ParserError<'i>>> {
1132  at_rule_parser
1133    .parse_block(prelude, start, input, options, is_nested)
1134    .map(|prelude| CssRule::Custom(prelude))
1135    .map_err(|err| match &err.kind {
1136      ParseErrorKind::Basic(kind) => ParseError {
1137        kind: ParseErrorKind::Basic(kind.clone()),
1138        location: err.location,
1139      },
1140      _ => input.new_error(BasicParseErrorKind::AtRuleBodyInvalid),
1141    })
1142}
1143
1144fn parse_custom_at_rule_without_block<'i, 't, T: crate::traits::AtRuleParser<'i>>(
1145  prelude: T::Prelude,
1146  start: &ParserState,
1147  options: &ParserOptions<'i>,
1148  at_rule_parser: &mut T,
1149  is_nested: bool,
1150) -> Result<CssRule<'i, T::AtRule>, ()> {
1151  at_rule_parser
1152    .rule_without_block(prelude, start, options, is_nested)
1153    .map(|prelude| CssRule::Custom(prelude))
1154}
1155
1156pub fn parse_rule_list<'a, 'i, 't, T: crate::traits::AtRuleParser<'i>>(
1157  input: &mut Parser<'i, 't>,
1158  options: &'a ParserOptions<'i>,
1159  at_rule_parser: &mut T,
1160) -> Result<CssRuleList<'i, T::AtRule>, ParseError<'i, ParserError<'i>>> {
1161  let mut parser = NestedRuleParser {
1162    options,
1163    at_rule_parser,
1164    declarations: DeclarationList::new(),
1165    important_declarations: DeclarationList::new(),
1166    rules: &mut CssRuleList(Vec::new()),
1167    is_in_style_rule: false,
1168    allow_declarations: false,
1169  };
1170
1171  let (_, rules) = parser.parse_nested(input, false)?;
1172  Ok(rules)
1173}
1174
1175pub fn parse_style_block<'a, 'i, 't, T: crate::traits::AtRuleParser<'i>>(
1176  input: &mut Parser<'i, 't>,
1177  options: &'a ParserOptions<'i>,
1178  at_rule_parser: &mut T,
1179  is_nested: bool,
1180) -> Result<CssRuleList<'i, T::AtRule>, ParseError<'i, ParserError<'i>>> {
1181  let mut parser = NestedRuleParser {
1182    options,
1183    at_rule_parser,
1184    declarations: DeclarationList::new(),
1185    important_declarations: DeclarationList::new(),
1186    rules: &mut CssRuleList(Vec::new()),
1187    is_in_style_rule: is_nested,
1188    allow_declarations: true,
1189  };
1190
1191  parser.parse_style_block(input)
1192}
1193
1194#[inline]
1195pub fn starts_with_ignore_ascii_case(string: &str, prefix: &str) -> bool {
1196  string.len() >= prefix.len() && string.as_bytes()[0..prefix.len()].eq_ignore_ascii_case(prefix.as_bytes())
1197}