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 #[derive(Clone, Debug, Default)]
50 #[cfg_attr(feature = "into_owned", derive(rspack_lightningcss_static_self::IntoOwned))]
51 pub struct ParserFlags: u8 {
52 const NESTING = 1 << 0;
54 const CUSTOM_MEDIA = 1 << 1;
56 const DEEP_SELECTOR_COMBINATOR = 1 << 2;
58 const SCROLL_NAVIGATION_CONTROLS = 1 << 3;
60 }
61}
62
63#[derive(Clone, Debug, Default)]
65pub struct ParserOptions<'i> {
66 pub filename: String,
68 pub css_modules: Option<crate::css_modules::Config>,
70 pub source_index: u32,
73 pub error_recovery: bool,
75 pub warnings: Option<Arc<RwLock<Vec<Error<ParserError<'i>>>>>>,
77 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
160pub 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#[derive(Debug)]
197#[allow(dead_code)]
198pub enum AtRulePrelude<'i, T> {
199 FontFace,
201 FontFeatureValues(Vec<FamilyName<'i>>),
203 FontPaletteValues(DashedIdent<'i>),
205 CounterStyle(CustomIdent<'i>),
207 Media(MediaList<'i>),
209 CustomMedia(DashedIdent<'i>, MediaList<'i>),
211 Supports(SupportsCondition<'i>),
213 Viewport(VendorPrefix),
215 Keyframes(KeyframesName<'i>, VendorPrefix),
217 Page(Vec<PageSelector<'i>>),
219 MozDocument,
221 Import(
223 CowRcStr<'i>,
224 MediaList<'i>,
225 Option<SupportsCondition<'i>>,
226 Option<Option<LayerName<'i>>>,
227 ),
228 Namespace(Option<CowRcStr<'i>>, CowRcStr<'i>),
230 Charset,
232 Nest(SelectorList<'i>),
234 Layer(Vec<LayerName<'i>>),
236 Property(DashedIdent<'i>),
238 PositionTry(DashedIdent<'i>),
240 Container(Option<ContainerName<'i>>, Option<ContainerCondition<'i>>),
244 StartingStyle,
246 Scope(Option<SelectorList<'i>>, Option<SelectorList<'i>>),
248 ViewTransition,
250 Unknown(CowArcStr<'i>, TokenList<'i>),
252 Custom(T),
254}
255
256impl<'i, T> AtRulePrelude<'i, T> {
257 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 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 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 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" => {
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 input.expect_function_matching("url-prefix")?;
644 input.parse_nested_block(|input| {
645 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 AtRulePrelude::Container(name, None)
676 } else {
677 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 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 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 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 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
1035impl<'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}