1use rustc_hash::FxHashSet;
4use smallvec::SmallVec;
5
6use crate::{
7 HandleWarning, Lexer, Pos,
8 css_syntax::{
9 MAX_CSS_KEYWORD_LEN, dashed_ident_name, dashed_ident_name_start, decode_css_keyword,
10 is_css_modules_magic_comment, is_css_modules_pure_magic_comment, is_css_space_byte,
11 is_css_white_space_char, lowercase_ascii_keyword, strip_vendor_prefix,
12 },
13 dependency_types::{
14 Dependency, DependencyContext, DependencyListRange, Mode, Range, UrlRangeKind,
15 ValueAtRuleImportItem, Warning, WarningKind,
16 },
17 lexer::{FunctionKind, LexerVisitor, Token, TokenFlags, TokenKind, TokenStream},
18 parser::{BlockItemKind, BlockItemProgress, RecoveryBoundary, resolve_block_item},
19};
20
21#[derive(Debug, Default)]
23pub struct DashedIdentCollector {
24 occurrences: Vec<Range>,
25 enabled: bool,
26}
27
28impl DashedIdentCollector {
29 #[inline(always)]
30 fn set_enabled(&mut self, enabled: bool) {
31 self.enabled = enabled;
32 }
33
34 fn reserve(&mut self, additional: usize) {
35 self.occurrences.reserve(additional);
36 }
37
38 fn take(&mut self) -> Vec<Range> {
39 std::mem::take(&mut self.occurrences)
40 }
41
42 fn discard_last(&mut self, range: Range) {
43 if self.occurrences.last() == Some(&range) {
44 self.occurrences.pop();
45 }
46 }
47}
48
49impl LexerVisitor for DashedIdentCollector {
50 #[inline(always)]
51 fn visit_ident(&mut self, name: &str, range: Range) {
52 if self.enabled
53 && let Some(name_start) = dashed_ident_name_start(name)
54 {
55 self
56 .occurrences
57 .push(Range::new(range.start + name_start as Pos, range.end));
58 }
59 }
60}
61
62type DependencyLexer<'s> = Lexer<'s, DashedIdentCollector>;
63type DependencyTokenStream<'a, 's> = TokenStream<'a, 's, DashedIdentCollector>;
64
65#[derive(Debug)]
66enum Scope<'s> {
67 TopLevel,
68 InBlock,
69 InAtImport(ImportData<'s>),
70 AtImportInvalid,
71 AtNamespaceInvalid,
72}
73
74#[derive(Debug, Clone, Copy, PartialEq, Eq)]
75enum ScanContext {
76 TopLevel,
77 BlockItem,
78 Selector,
79 DeclarationName,
80 GenericValue,
81 SpecialValue(PropertyKind),
82 AtRule,
83}
84
85#[derive(Debug, Clone, Copy, PartialEq, Eq)]
86pub(crate) enum PropertyKind {
87 Generic,
88 Animation,
89 ListStyle,
90 FontPalette,
91 Container,
92 Grid,
93 Composes,
94 CustomProperty,
95}
96
97#[derive(Debug, Clone, Copy, PartialEq, Eq)]
98enum AtRuleKind {
99 Namespace,
100 Import,
101 Charset,
102 Value,
103 Keyframes,
104 Container,
105 Function,
106 Property,
107 CounterStyle,
108 FontPaletteValues,
109 Scope,
110 Other,
111}
112
113impl ScanContext {
114 fn for_property(property: PropertyKind) -> Self {
115 if property == PropertyKind::Generic {
116 Self::GenericValue
117 } else {
118 Self::SpecialValue(property)
119 }
120 }
121}
122
123#[derive(Debug)]
124struct ImportData<'s> {
125 start: Pos,
126 magic_comments: Option<&'s str>,
127 prelude: ImportPrelude<'s>,
128 url: Option<&'s str>,
129 url_flags: TokenFlags,
130 url_range: Option<Range>,
131 supports: ImportDataSupports<'s>,
132 layer: ImportDataLayer<'s>,
133}
134
135impl ImportData<'_> {
136 pub fn new(start: Pos) -> Self {
137 Self {
138 start,
139 magic_comments: None,
140 prelude: ImportPrelude::default(),
141 url: None,
142 url_flags: TokenFlags::ascii(),
143 url_range: None,
144 supports: ImportDataSupports::None,
145 layer: ImportDataLayer::None,
146 }
147 }
148
149 pub fn in_supports(&self) -> bool {
150 matches!(self.supports, ImportDataSupports::InSupports { .. })
151 }
152
153 pub fn layer_range(&self) -> Option<&Range> {
154 let ImportDataLayer::EndLayer { range, .. } = &self.layer else {
155 return None;
156 };
157 Some(range)
158 }
159
160 pub fn supports_range(&self) -> Option<&Range> {
161 let ImportDataSupports::EndSupports { range, .. } = &self.supports else {
162 return None;
163 };
164 Some(range)
165 }
166}
167
168#[derive(Debug, Default)]
169struct ImportPrelude<'s>(SmallVec<[ImportPreludeNode<'s>; 2]>);
170
171impl<'s> ImportPrelude<'s> {
172 pub fn push(&mut self, node: ImportPreludeNode<'s>) {
173 self.0.push(node);
174 }
175
176 pub fn is_empty(&self) -> bool {
177 self.0.is_empty()
178 }
179
180 pub fn icss_import_url(&self) -> Option<(&'s str, &Range)> {
181 let [ImportPreludeNode::IcssUrlCandidate { name, range }] = self.0.as_slice() else {
182 return None;
183 };
184 Some((name, range))
185 }
186
187 pub fn first_non_url_before(&self, url_range: &Range) -> Option<&Range> {
188 self.0.iter().find_map(|node| {
189 let range = node.range();
190 if range.start >= url_range.start || matches!(node, ImportPreludeNode::Url { .. }) {
191 None
192 } else {
193 Some(range)
194 }
195 })
196 }
197}
198
199#[derive(Debug)]
200enum ImportPreludeNode<'s> {
201 IcssUrlCandidate { name: &'s str, range: Range },
202 Url { range: Range },
203 Layer { range: Range },
204 Supports { range: Range },
205 Other { range: Range },
206}
207
208impl ImportPreludeNode<'_> {
209 fn range(&self) -> &Range {
210 match self {
211 Self::IcssUrlCandidate { range, .. }
212 | Self::Url { range }
213 | Self::Layer { range }
214 | Self::Supports { range }
215 | Self::Other { range } => range,
216 }
217 }
218}
219
220#[derive(Debug)]
221enum ImportDataSupports<'s> {
222 None,
223 InSupports,
224 EndSupports { value: &'s str, range: Range },
225}
226
227#[derive(Debug)]
228enum ImportDataLayer<'s> {
229 None,
230 EndLayer { value: &'s str, range: Range },
231}
232
233#[derive(Debug, Default)]
234struct BalancedStack(SmallVec<[BalancedItem; 3]>);
235
236impl BalancedStack {
237 pub fn len(&self) -> usize {
238 self.0.len()
239 }
240
241 pub fn last(&self) -> Option<&BalancedItem> {
242 self.0.last()
243 }
244
245 pub fn is_empty(&self) -> bool {
246 self.0.is_empty()
247 }
248
249 fn last_component(&self) -> Option<&BalancedItem> {
250 self.0.iter().rev().find(|item| !item.kind.is_mode_class())
251 }
252
253 pub fn push(&mut self, item: BalancedItem, mode_data: Option<&mut ModeData>) {
254 if let Some(mode_data) = mode_data {
255 if item.kind.is_mode_local() {
256 mode_data.set_current_mode(Mode::Local);
257 } else if item.kind.is_mode_global() {
258 mode_data.set_current_mode(Mode::Global);
259 }
260
261 if item.kind.is_mode_function() {
262 mode_data.inside_mode_function += 1;
263 } else if item.kind.is_mode_class() {
264 mode_data.inside_mode_class += 1;
265 }
266 }
267 self.0.push(item);
268 }
269
270 pub fn pop(&mut self, mode_data: Option<&mut ModeData>) -> Option<BalancedItem> {
271 let item = self.0.pop()?;
272 if let Some(mode_data) = mode_data {
273 if item.kind.is_mode_function() {
274 mode_data.inside_mode_function -= 1;
275 } else if item.kind.is_mode_class() {
276 mode_data.inside_mode_class -= 1;
277 }
278 self.update_current_mode(mode_data);
279 }
280 Some(item)
281 }
282
283 pub fn pop_without_moda_data(&mut self) -> Option<BalancedItem> {
284 self.0.pop()
285 }
286
287 pub fn pop_mode_pseudo_class(&mut self, mode_data: &mut ModeData) {
288 loop {
289 if let Some(last) = self.0.last()
290 && matches!(
291 last.kind,
292 BalancedItemKind::LocalClass | BalancedItemKind::GlobalClass
293 )
294 {
295 mode_data.inside_mode_class -= 1;
296 self.0.pop();
297 continue;
298 }
299 break;
300 }
301 self.update_current_mode(mode_data);
302 }
303
304 pub fn update_current_mode(&self, mode_data: &mut ModeData) {
305 mode_data.set_current_mode(self.topmost_mode(mode_data));
306 }
307
308 pub fn update_property_mode(&self, mode_data: &mut ModeData) {
309 mode_data.set_property_mode(self.topmost_mode(mode_data));
310 }
311
312 fn topmost_mode(&self, mode_data: &ModeData) -> Mode {
313 let mut iter = self.0.iter();
314 loop {
315 if let Some(last) = iter.next_back() {
316 if matches!(
317 last.kind,
318 BalancedItemKind::LocalFn | BalancedItemKind::LocalClass
319 ) {
320 return Mode::Local;
321 } else if matches!(
322 last.kind,
323 BalancedItemKind::GlobalFn | BalancedItemKind::GlobalClass
324 ) {
325 return Mode::Global;
326 }
327 } else {
328 return mode_data.default_mode();
329 }
330 }
331 }
332}
333
334#[derive(Debug)]
335struct BalancedItem {
336 kind: BalancedItemKind,
337 range: Range,
338 magic_comments: Option<Range>,
339}
340
341impl BalancedItem {
342 pub fn new_mode_class(local: bool, start: Pos, end: Pos) -> Self {
343 Self {
344 kind: if local {
345 BalancedItemKind::LocalClass
346 } else {
347 BalancedItemKind::GlobalClass
348 },
349 range: Range::new(start, end),
350 magic_comments: None,
351 }
352 }
353
354 pub fn new_function(kind: FunctionKind, start: Pos, end: Pos) -> Self {
355 Self {
356 kind: match kind {
357 FunctionKind::Url => BalancedItemKind::Url,
358 FunctionKind::ImageSet => BalancedItemKind::ImageSet,
359 FunctionKind::Layer => BalancedItemKind::Layer,
360 FunctionKind::Supports => BalancedItemKind::Supports,
361 FunctionKind::PaletteMix => BalancedItemKind::PaletteMix,
362 _ => BalancedItemKind::Other,
363 },
364 range: Range::new(start, end),
365 magic_comments: None,
366 }
367 }
368
369 pub fn new_pseudo_function(kind: FunctionKind, start: Pos, end: Pos) -> Self {
370 Self {
371 kind: match kind {
372 FunctionKind::Local => BalancedItemKind::LocalFn,
373 FunctionKind::Global => BalancedItemKind::GlobalFn,
374 _ => BalancedItemKind::Other,
375 },
376 range: Range::new(start, end),
377 magic_comments: None,
378 }
379 }
380
381 pub fn new_other(start: Pos, end: Pos) -> Self {
382 Self {
383 kind: BalancedItemKind::Other,
384 range: Range::new(start, end),
385 magic_comments: None,
386 }
387 }
388
389 pub fn new_square(start: Pos, end: Pos) -> Self {
390 Self {
391 kind: BalancedItemKind::Square,
392 range: Range::new(start, end),
393 magic_comments: None,
394 }
395 }
396
397 pub fn new_curly(start: Pos, end: Pos) -> Self {
398 Self {
399 kind: BalancedItemKind::Curly,
400 range: Range::new(start, end),
401 magic_comments: None,
402 }
403 }
404}
405
406#[derive(Debug)]
407enum BalancedItemKind {
408 Url,
409 ImageSet,
410 Layer,
411 Supports,
412 PaletteMix,
413 LocalFn,
414 GlobalFn,
415 LocalClass,
416 GlobalClass,
417 Curly,
418 Square,
419 Other,
420}
421
422impl BalancedItemKind {
423 pub fn is_mode_local(&self) -> bool {
424 matches!(self, Self::LocalFn | Self::LocalClass)
425 }
426
427 pub fn is_mode_global(&self) -> bool {
428 matches!(self, Self::GlobalFn | Self::GlobalClass)
429 }
430
431 pub fn is_mode_function(&self) -> bool {
432 matches!(self, Self::LocalFn | Self::GlobalFn)
433 }
434
435 pub fn is_mode_class(&self) -> bool {
436 matches!(self, Self::LocalClass | Self::GlobalClass)
437 }
438}
439
440fn preceding_comment_range(input: &str) -> Option<Range> {
441 let bytes = input.as_bytes();
442 let mut cursor = bytes.len();
443 let end = cursor as Pos;
444 let mut start = None;
445
446 loop {
447 while cursor > 0 && is_css_space_byte(bytes[cursor - 1]) {
448 cursor -= 1;
449 }
450 if cursor < 2 || &bytes[cursor - 2..cursor] != b"*/" {
451 break;
452 }
453 let Some(comment_start) = input[..cursor - 2].rfind("/*") else {
454 break;
455 };
456 start = Some(comment_start as Pos);
457 cursor = comment_start;
458 }
459
460 start.map(|start| Range::new(start, end))
461}
462
463fn trivia_only(input: &str) -> bool {
464 if input.is_empty() {
465 return false;
466 }
467 let bytes = input.as_bytes();
468 let mut position = 0;
469 while position < bytes.len() {
470 if is_css_space_byte(bytes[position]) {
471 position += 1;
472 continue;
473 }
474 if position + 1 < bytes.len() && bytes[position] == b'/' && bytes[position + 1] == b'*' {
475 position += 2;
476 while position + 1 < bytes.len() && !(bytes[position] == b'*' && bytes[position + 1] == b'/')
477 {
478 position += 1;
479 }
480 if position + 1 >= bytes.len() {
481 return false;
482 }
483 position += 2;
484 continue;
485 }
486 return false;
487 }
488 true
489}
490
491fn token_text(input: &str, token: Token) -> &str {
492 Lexer::slice_range(input, &token.range).unwrap_or("")
493}
494
495fn is_ascii_keyword(name: &str, expected: &str) -> bool {
496 name.eq_ignore_ascii_case(expected)
497}
498
499fn is_open_token(kind: TokenKind) -> bool {
500 matches!(
501 kind,
502 TokenKind::Function
503 | TokenKind::LeftParenthesis
504 | TokenKind::LeftSquareBracket
505 | TokenKind::LeftCurlyBracket
506 )
507}
508
509fn is_close_token(kind: TokenKind) -> bool {
510 matches!(
511 kind,
512 TokenKind::RightParenthesis | TokenKind::RightSquareBracket | TokenKind::RightCurlyBracket
513 )
514}
515
516fn ident_like_range(token: Token) -> Option<Range> {
517 match token.kind {
518 TokenKind::Ident => Some(token.range),
519 TokenKind::Function => Some(token.value_range),
520 _ => None,
521 }
522}
523
524#[derive(Debug, Clone, Copy)]
528struct ValueAtRuleSplit {
529 split: Pos,
530 end: Pos,
531 prev_end: Pos,
532 next_start: Option<Pos>,
533}
534
535struct ValueAtRuleStream<'s> {
539 input: &'s str,
540 depth: u32,
541 params_end: Pos,
542 first_significant: Option<(Pos, Pos)>,
543 significant_count: u32,
544 first_colon: Option<ValueAtRuleSplit>,
545 first_colon_tokens_after: u32,
546 item_start: Option<Pos>,
547 item_end: Pos,
548 item_colon: Option<ValueAtRuleSplit>,
549 item_as: Option<ValueAtRuleSplit>,
550 last_significant: Option<Token>,
551 penultimate_significant: Option<Token>,
552 from_pos: Option<Pos>,
553 from_prev_end: Option<Pos>,
554}
555
556impl<'s> ValueAtRuleStream<'s> {
557 fn new(input: &'s str) -> Self {
558 Self {
559 input,
560 depth: 0,
561 params_end: 0,
562 first_significant: None,
563 significant_count: 0,
564 first_colon: None,
565 first_colon_tokens_after: 0,
566 item_start: None,
567 item_end: 0,
568 item_colon: None,
569 item_as: None,
570 last_significant: None,
571 penultimate_significant: None,
572 from_pos: None,
573 from_prev_end: None,
574 }
575 }
576
577 fn push(&mut self, context: &mut DependencyContext<'s>, token: Token) {
578 if matches!(token.kind, TokenKind::Comment | TokenKind::BadComment) {
579 self.params_end = token.range.end;
580 return;
581 }
582 self.params_end = token.range.end;
583 if self.first_significant.is_none() {
584 self.first_significant = Some((token.range.start, token.range.end));
585 }
586 self.significant_count += 1;
587 let had_first_colon = self.first_colon.is_some();
588
589 self.depth = (self.depth + u32::from(is_open_token(token.kind)))
590 .saturating_sub(u32::from(is_close_token(token.kind)));
591 let at_top = self.depth == 0;
592 let is_ident = token.kind == TokenKind::Ident;
593 if is_ident && self.significant_count > 1 {
594 context.push_value_at_rule_identifier(token.range);
595 }
596 let text = if is_ident {
597 self
598 .input
599 .get(token.range.start as usize..token.range.end as usize)
600 .unwrap_or("")
601 } else {
602 ""
603 };
604 if at_top {
605 if token.kind == TokenKind::Colon {
606 let split = ValueAtRuleSplit {
607 split: token.range.start,
608 end: token.range.end,
609 prev_end: self
610 .last_significant
611 .map_or(token.range.start, |previous| previous.range.end),
612 next_start: None,
613 };
614 if self.first_colon.is_none() {
615 self.first_colon = Some(split);
616 }
617 if self.item_colon.is_none() {
618 self.item_colon = Some(split);
619 }
620 }
621 if is_ident && text.eq_ignore_ascii_case("as") {
622 self.item_as = Some(ValueAtRuleSplit {
623 split: token.range.start,
624 end: token.range.end,
625 prev_end: self
626 .last_significant
627 .map_or(token.range.start, |previous| previous.range.end),
628 next_start: None,
629 });
630 }
631 if is_ident
632 && text.eq_ignore_ascii_case("from")
633 && let Some(previous) = self.last_significant
634 {
635 let gap = self
636 .input
637 .get(previous.range.end as usize..token.range.start as usize)
638 .unwrap_or("");
639 if trivia_only(gap) {
640 self.from_pos = Some(token.range.start);
641 self.from_prev_end = Some(previous.range.end);
642 }
643 }
644 self.penultimate_significant = self.last_significant;
645 self.last_significant = Some(token);
646 }
647 if had_first_colon {
648 self.first_colon_tokens_after += 1;
649 }
650
651 if token.kind == TokenKind::Comma && at_top {
652 self.finish_item(context, self.item_end);
653 self.item_start = None;
654 self.item_colon = None;
655 self.item_as = None;
656 } else {
657 if self.item_start.is_none() {
658 self.item_start = Some(token.range.start);
659 }
660 self.item_end = token.range.end;
661 if let Some(split) = self.item_colon.as_mut()
662 && split.next_start.is_none()
663 && split.split != token.range.start
664 {
665 split.next_start = Some(token.range.start);
666 }
667 if let Some(split) = self.item_as.as_mut()
668 && split.next_start.is_none()
669 && split.split != token.range.start
670 {
671 split.next_start = Some(token.range.start);
672 }
673 }
674 }
675
676 fn finish_item(&mut self, context: &mut DependencyContext<'s>, end: Pos) {
677 let Some(item_start) = self.item_start else {
678 return;
679 };
680 if end.saturating_sub(item_start) >= 2
681 && self.input.as_bytes()[item_start as usize] == b'('
682 && self.input.as_bytes()[end as usize - 1] == b')'
683 {
684 self.parse_paren_items(context, item_start + 1, end - 1);
685 } else {
686 let item = self.build_item(item_start, end, self.item_colon, self.item_as);
687 if !item.local_name().is_empty() || !item.import_name().is_empty() {
688 context.push_value_at_rule_import_item(item);
689 }
690 }
691 }
692
693 fn build_item(
694 &self,
695 start: Pos,
696 end: Pos,
697 colon: Option<ValueAtRuleSplit>,
698 as_split: Option<ValueAtRuleSplit>,
699 ) -> ValueAtRuleImportItem<'s> {
700 let slice = |a: Pos, b: Pos| -> &'s str {
701 if a >= b {
702 ""
703 } else {
704 &self.input[a as usize..b as usize]
705 }
706 };
707 if let Some(split) = colon {
708 return ValueAtRuleImportItem::new(
709 slice(start, split.prev_end),
710 split
711 .next_start
712 .map_or("", |next_start| slice(next_start, end)),
713 );
714 }
715 if let Some(split) = as_split {
716 let import_name = slice(start, split.prev_end);
717 let local_name = split
718 .next_start
719 .map_or("", |next_start| slice(next_start, end));
720 if !import_name.is_empty() && !local_name.is_empty() {
721 return ValueAtRuleImportItem::new(local_name, import_name);
722 }
723 }
724 let value = slice(start, end);
725 ValueAtRuleImportItem::new(value, value)
726 }
727
728 fn parse_paren_items(&mut self, context: &mut DependencyContext<'s>, start: Pos, end: Pos) {
732 let slice = &self.input[start as usize..end as usize];
733 let mut lexer = Lexer::new(slice, ());
734 let mut tokens: SmallVec<[Token; 8]> = SmallVec::new();
735 loop {
736 let token = lexer.next_token();
737 if token.kind == TokenKind::Eof {
738 break;
739 }
740 if matches!(
741 token.kind,
742 TokenKind::Comment | TokenKind::BadComment | TokenKind::WhiteSpace
743 ) {
744 continue;
745 }
746 tokens.push(token);
747 }
748 let mut item_start = 0;
749 let mut item_depth = 0u32;
750 for (index, token) in tokens.iter().copied().enumerate() {
751 if is_close_token(token.kind) {
752 item_depth = item_depth.saturating_sub(1);
753 }
754 if token.kind == TokenKind::Comma && item_depth == 0 {
755 self.push_parsed_item(context, &tokens, item_start, index, slice);
756 item_start = index + 1;
757 }
758 if is_open_token(token.kind) {
759 item_depth += 1;
760 }
761 }
762 self.push_parsed_item(context, &tokens, item_start, tokens.len(), slice);
763 }
764
765 fn push_parsed_item(
766 &mut self,
767 context: &mut DependencyContext<'s>,
768 tokens: &[Token],
769 start: usize,
770 end: usize,
771 slice: &'s str,
772 ) {
773 let mut depth = 0u32;
774 let mut colon_index = None;
775 let mut as_index = None;
776 for (index, token) in tokens[start..end].iter().copied().enumerate() {
777 let index = start + index;
778 if is_close_token(token.kind) {
779 depth = depth.saturating_sub(1);
780 }
781 if depth == 0 {
782 if token.kind == TokenKind::Colon && colon_index.is_none() {
783 colon_index = Some(index);
784 }
785 if token.kind == TokenKind::Ident && token_text(slice, token).eq_ignore_ascii_case("as") {
786 as_index = Some(index);
787 }
788 }
789 if is_open_token(token.kind) {
790 depth += 1;
791 }
792 }
793 let span = |a: usize, b: usize| -> &'s str {
794 if a >= b {
795 ""
796 } else {
797 &slice[tokens[a].range.start as usize..tokens[b - 1].range.end as usize]
798 }
799 };
800 let item = if let Some(index) = colon_index {
801 ValueAtRuleImportItem::new(span(start, index), span(index + 1, end))
802 } else if let Some(index) = as_index {
803 let import_name = span(start, index);
804 let local_name = span(index + 1, end);
805 if !import_name.is_empty() && !local_name.is_empty() {
806 ValueAtRuleImportItem::new(local_name, import_name)
807 } else {
808 ValueAtRuleImportItem::new("", "")
809 }
810 } else {
811 let value = span(start, end);
812 ValueAtRuleImportItem::new(value, value)
813 };
814 if !item.local_name().is_empty() || !item.import_name().is_empty() {
815 context.push_value_at_rule_import_item(item);
816 }
817 }
818
819 fn last_two(&self) -> Option<(Token, Token)> {
822 Some((self.penultimate_significant?, self.last_significant?))
823 }
824}
825
826#[derive(Debug)]
827pub struct ModeData<'s> {
828 default: Mode,
829 current: Mode,
830 property: Mode,
831 resulting_global: Option<Pos>,
832 pure_global: Option<Pos>,
833 pure_no_check: bool,
834 pure_ignore_pending: bool,
835 pure_ignored_block_nesting_level: Option<u32>,
836 composes_local_classes: ComposesLocalClasses<'s>,
837 inside_mode_function: u32,
838 inside_mode_class: u32,
839}
840
841impl ModeData<'_> {
842 pub fn new(default: Mode) -> Self {
843 Self {
844 default,
845 current: default,
846 property: default,
847 resulting_global: None,
848 pure_global: Some(0),
849 pure_no_check: false,
850 pure_ignore_pending: false,
851 pure_ignored_block_nesting_level: None,
852 composes_local_classes: ComposesLocalClasses::default(),
853 inside_mode_function: 0,
854 inside_mode_class: 0,
855 }
856 }
857
858 pub fn is_pure_mode(&self) -> bool {
859 matches!(self.default, Mode::Pure)
860 }
861
862 pub fn mark_pure_ignore(&mut self) {
863 if self.is_pure_mode() {
864 self.pure_ignore_pending = true;
865 }
866 }
867
868 pub fn mark_pure_no_check(&mut self) {
869 if self.is_pure_mode() {
870 self.pure_no_check = true;
871 }
872 }
873
874 pub fn is_pure_check_disabled(&self) -> bool {
875 self.pure_no_check
876 || self.pure_ignore_pending
877 || self.pure_ignored_block_nesting_level.is_some()
878 }
879
880 pub fn enter_block(&mut self, block_nesting_level: u32) {
881 if self.pure_ignore_pending {
882 self.pure_ignore_pending = false;
883 if self.pure_ignored_block_nesting_level.is_none() {
884 self.pure_ignored_block_nesting_level = Some(block_nesting_level);
885 }
886 }
887 }
888
889 pub fn clear_pure_ignore_pending(&mut self) {
890 self.pure_ignore_pending = false;
891 }
892
893 pub fn exit_block(&mut self, block_nesting_level: u32) {
894 if self
895 .pure_ignored_block_nesting_level
896 .is_some_and(|level| block_nesting_level < level)
897 {
898 self.pure_ignored_block_nesting_level = None;
899 }
900 }
901
902 pub fn is_current_local_mode(&self) -> bool {
903 match self.current {
904 Mode::Local | Mode::Pure => true,
905 Mode::Global | Mode::Css => false,
906 }
907 }
908
909 pub fn is_property_local_mode(&self) -> bool {
910 match self.property {
911 Mode::Local | Mode::Pure => true,
912 Mode::Global | Mode::Css => false,
913 }
914 }
915
916 pub fn default_mode(&self) -> Mode {
917 self.default
918 }
919
920 pub fn set_current_mode(&mut self, mode: Mode) {
921 self.current = mode;
922 }
923
924 pub fn set_property_mode(&mut self, mode: Mode) {
925 self.property = mode;
926 }
927
928 pub fn is_inside_mode_function(&self) -> bool {
929 self.inside_mode_function > 0
930 }
931
932 pub fn is_inside_mode_class(&self) -> bool {
933 self.inside_mode_class > 0
934 }
935
936 pub fn is_mode_explicit(&self) -> bool {
937 self.is_inside_mode_function() || self.is_inside_mode_class()
938 }
939}
940
941#[derive(Debug, Default, Clone)]
942struct ComposesLocalClasses<'s> {
943 is_single: SingleLocalClass,
944 local_classes: SmallVec<[&'s str; 2]>,
945}
946
947impl<'s> ComposesLocalClasses<'s> {
948 pub fn get_valid_local_classes(
949 &mut self,
950 lexer: &DependencyLexer<'s>,
951 ) -> Option<SmallVec<[&'s str; 2]>> {
952 if let SingleLocalClass::Single(range) = &self.is_single {
953 let mut local_classes = self.local_classes.clone();
954 local_classes.push(lexer.slice(range.start, range.end)?);
955 Some(local_classes)
956 } else {
957 self.reset_to_initial();
958 None
959 }
960 }
961
962 pub fn invalidate(&mut self) {
963 if !matches!(self.is_single, SingleLocalClass::AtKeyword) {
964 self.is_single = SingleLocalClass::Invalid;
965 self.local_classes.clear();
966 }
967 }
968
969 pub fn find_local_class(&mut self, start: Pos, end: Pos) {
970 match self.is_single {
971 SingleLocalClass::Initial => {
972 self.is_single = SingleLocalClass::Single(Range::new(start, end))
973 }
974 SingleLocalClass::Single(_) => {
975 self.is_single = SingleLocalClass::Invalid;
976 self.local_classes.clear();
977 }
978 _ => {}
979 };
980 }
981
982 pub fn find_at_keyword(&mut self) {
983 self.is_single = SingleLocalClass::AtKeyword;
984 self.local_classes.clear();
985 }
986
987 pub fn reset_to_initial(&mut self) {
988 self.is_single = SingleLocalClass::Initial;
989 self.local_classes.clear();
990 }
991
992 pub fn find_comma(&mut self, lexer: &DependencyLexer<'s>) -> Option<()> {
993 if let SingleLocalClass::Single(range) = &self.is_single {
994 self
995 .local_classes
996 .push(lexer.slice(range.start, range.end)?);
997 self.is_single = SingleLocalClass::Initial
998 } else {
999 self.is_single = SingleLocalClass::Invalid;
1000 }
1001 Some(())
1002 }
1003}
1004
1005#[derive(Debug, Default, Clone)]
1006enum SingleLocalClass {
1007 #[default]
1008 Initial,
1009 Single(Range),
1010 AtKeyword,
1011 Invalid,
1012}
1013
1014#[derive(Debug)]
1015struct InProperty<T: ReservedValues> {
1016 reserved: T,
1017 rename: Option<Range>,
1018 balanced_len: usize,
1019 important_pending: bool,
1020}
1021
1022impl<T: ReservedValues> InProperty<T> {
1023 pub fn new(reserved: T, balanced_len: usize) -> Self {
1024 Self {
1025 reserved,
1026 rename: None,
1027 balanced_len,
1028 important_pending: false,
1029 }
1030 }
1031
1032 fn check_reserved(&mut self, ident: &str, flags: TokenFlags) -> bool {
1033 self.reserved.check(ident, flags)
1034 }
1035
1036 pub fn reset_reserved(&mut self) {
1037 self.reserved.reset();
1038 }
1039
1040 pub fn set_rename(&mut self, ident: &str, flags: TokenFlags, range: Range) {
1041 if self.check_reserved(ident, flags) {
1042 self.rename = Some(range);
1043 }
1044 }
1045
1046 pub fn take_rename(&mut self, balanced_len: usize) -> Option<Range> {
1047 if balanced_len != self.balanced_len {
1049 return None;
1050 }
1051 std::mem::take(&mut self.rename)
1052 }
1053}
1054
1055trait ReservedValues {
1056 fn check(&mut self, ident: &str, flags: TokenFlags) -> bool;
1057 fn reset(&mut self);
1058}
1059
1060#[derive(Debug, Default)]
1061struct AnimationReserved {
1062 bits: u32,
1063}
1064
1065impl ReservedValues for AnimationReserved {
1066 fn check(&mut self, ident: &str, flags: TokenFlags) -> bool {
1067 let mut lowercase = [0; MAX_CSS_KEYWORD_LEN];
1068 let ident = if flags.has_escape() {
1069 decode_css_keyword(ident, &mut lowercase)
1070 } else {
1071 lowercase_ascii_keyword(ident, &mut lowercase)
1072 };
1073 let Some(ident) = ident else {
1074 return true;
1075 };
1076 match ident {
1077 "normal" => self.check_and_update(Self::NORMAL),
1078 "reverse" => self.check_and_update(Self::REVERSE),
1079 "alternate" => self.check_and_update(Self::ALTERNATE),
1080 "alternate-reverse" => self.check_and_update(Self::ALTERNATE_REVERSE),
1081 "forwards" => self.check_and_update(Self::FORWARDS),
1082 "backwards" => self.check_and_update(Self::BACKWARDS),
1083 "both" => self.check_and_update(Self::BOTH),
1084 "infinite" => self.check_and_update(Self::INFINITE),
1085 "paused" => self.check_and_update(Self::PAUSED),
1086 "running" => self.check_and_update(Self::RUNNING),
1087 "ease" => self.check_and_update(Self::EASE),
1088 "ease-in" => self.check_and_update(Self::EASE_IN),
1089 "ease-out" => self.check_and_update(Self::EASE_OUT),
1090 "ease-in-out" => self.check_and_update(Self::EASE_IN_OUT),
1091 "linear" => self.check_and_update(Self::LINEAR),
1092 "step-end" => self.check_and_update(Self::STEP_END),
1093 "step-start" => self.check_and_update(Self::STEP_START),
1094 "none" |
1096 "initial" | "inherit" | "unset" | "revert" | "revert-layer" => false,
1098 _ => true,
1099 }
1100 }
1101
1102 fn reset(&mut self) {
1103 self.bits = 0;
1104 }
1105}
1106
1107impl AnimationReserved {
1108 const NORMAL: u32 = 1 << 0;
1109 const REVERSE: u32 = 1 << 1;
1110 const ALTERNATE: u32 = 1 << 2;
1111 const ALTERNATE_REVERSE: u32 = 1 << 3;
1112 const FORWARDS: u32 = 1 << 4;
1113 const BACKWARDS: u32 = 1 << 5;
1114 const BOTH: u32 = 1 << 6;
1115 const INFINITE: u32 = 1 << 7;
1116 const PAUSED: u32 = 1 << 8;
1117 const RUNNING: u32 = 1 << 9;
1118 const EASE: u32 = 1 << 10;
1119 const EASE_IN: u32 = 1 << 11;
1120 const EASE_OUT: u32 = 1 << 12;
1121 const EASE_IN_OUT: u32 = 1 << 13;
1122 const LINEAR: u32 = 1 << 14;
1123 const STEP_END: u32 = 1 << 15;
1124 const STEP_START: u32 = 1 << 16;
1125
1126 fn check_and_update(&mut self, bit: u32) -> bool {
1127 if self.bits & bit == bit {
1128 return true;
1129 }
1130 self.bits |= bit;
1131 false
1132 }
1133}
1134
1135#[derive(Debug, Default)]
1136struct ListStyleReserved;
1137
1138impl ReservedValues for ListStyleReserved {
1139 fn check(&mut self, ident: &str, flags: TokenFlags) -> bool {
1140 let mut lowercase = [0; MAX_CSS_KEYWORD_LEN];
1141 let ident = if flags.has_escape() {
1142 decode_css_keyword(ident, &mut lowercase)
1143 } else {
1144 lowercase_ascii_keyword(ident, &mut lowercase)
1145 };
1146 let Some(ident) = ident else {
1147 return true;
1148 };
1149 match ident {
1150 "decimal"
1152 | "decimal-leading-zero"
1153 | "arabic-indic"
1154 | "armenian"
1155 | "upper-armenian"
1156 | "lower-armenian"
1157 | "bengali"
1158 | "cambodian"
1159 | "khmer"
1160 | "cjk-decimal"
1161 | "devanagari"
1162 | "georgian"
1163 | "gujarati"
1164 | "gurmukhi"
1165 | "hebrew"
1166 | "kannada"
1167 | "lao"
1168 | "malayalam"
1169 | "mongolian"
1170 | "myanmar"
1171 | "oriya"
1172 | "persian"
1173 | "lower-roman"
1174 | "upper-roman"
1175 | "tamil"
1176 | "telugu"
1177 | "thai"
1178 | "tibetan"
1179 | "lower-alpha"
1181 | "lower-latin"
1182 | "upper-alpha"
1183 | "upper-latin"
1184 | "lower-greek"
1185 | "hiragana"
1186 | "hiragana-iroha"
1187 | "katakana"
1188 | "katakana-iroha"
1189 | "disc"
1191 | "circle"
1192 | "square"
1193 | "disclosure-open"
1194 | "disclosure-closed"
1195 | "cjk-earthly-branch"
1197 | "cjk-heavenly-stem"
1198 | "japanese-informal"
1200 | "japanese-formal"
1201 | "korean-hangul-formal"
1202 | "korean-hanja-informal"
1203 | "korean-hanja-formal"
1204 | "simp-chinese-informal"
1205 | "simp-chinese-formal"
1206 | "trad-chinese-informal"
1207 | "trad-chinese-formal"
1208 | "ethiopic-numeric"
1209 | "none"
1211 | "initial"
1213 | "inherit"
1214 | "unset"
1215 | "revert"
1216 | "revert-layer" => false,
1217 _ => true,
1218 }
1219 }
1220
1221 fn reset(&mut self) {}
1222}
1223
1224#[derive(Debug, Default)]
1225struct FontPaletteReserved;
1226
1227impl ReservedValues for FontPaletteReserved {
1228 fn check(&mut self, ident: &str, _flags: TokenFlags) -> bool {
1229 ident.starts_with("--")
1230 }
1231
1232 fn reset(&mut self) {}
1233}
1234
1235#[derive(Debug, Default)]
1236struct ContainerReserved;
1237
1238impl ReservedValues for ContainerReserved {
1239 fn check(&mut self, ident: &str, flags: TokenFlags) -> bool {
1240 let mut lowercase = [0; MAX_CSS_KEYWORD_LEN];
1241 let ident = if flags.has_escape() {
1242 decode_css_keyword(ident, &mut lowercase)
1243 } else {
1244 lowercase_ascii_keyword(ident, &mut lowercase)
1245 };
1246 let Some(ident) = ident else {
1247 return true;
1248 };
1249 !matches!(
1250 ident,
1251 "normal"
1252 | "size"
1253 | "inline-size"
1254 | "scroll-state"
1255 | "none"
1256 | "initial"
1257 | "inherit"
1258 | "unset"
1259 | "revert"
1260 | "revert-layer"
1261 )
1262 }
1263
1264 fn reset(&mut self) {}
1265}
1266
1267#[derive(Debug, Clone, Copy)]
1268enum GridPropertyKind {
1269 Generic,
1270 TemplateLike,
1271 TemplateAreas,
1272}
1273
1274fn grid_property_kind(ident: &str) -> Option<GridPropertyKind> {
1275 match ident {
1276 "grid" | "grid-area" | "grid-column" | "grid-column-end" | "grid-column-start" | "grid-row"
1277 | "grid-row-end" | "grid-row-start" => Some(GridPropertyKind::Generic),
1278 "grid-template" | "grid-template-columns" | "grid-template-rows" => {
1279 Some(GridPropertyKind::TemplateLike)
1280 }
1281 "grid-template-areas" => Some(GridPropertyKind::TemplateAreas),
1282 _ => None,
1283 }
1284}
1285
1286fn is_reserved_grid_ident(ident: &str, flags: TokenFlags) -> bool {
1287 let mut lowercase = [0; MAX_CSS_KEYWORD_LEN];
1288 let ident = if flags.has_escape() {
1289 decode_css_keyword(ident, &mut lowercase)
1290 } else {
1291 lowercase_ascii_keyword(ident, &mut lowercase)
1292 };
1293 let Some(ident) = ident else {
1294 return false;
1295 };
1296 matches!(
1297 ident,
1298 "auto"
1299 | "span"
1300 | "auto-flow"
1301 | "dense"
1302 | "row"
1303 | "column"
1304 | "none"
1305 | "subgrid"
1306 | "masonry"
1307 | "max-content"
1308 | "min-content"
1309 | "initial"
1310 | "inherit"
1311 | "unset"
1312 | "revert"
1313 | "revert-layer"
1314 )
1315}
1316
1317pub(crate) fn special_value_is_candidate(
1325 property: PropertyKind,
1326 ident: &str,
1327 icss_symbols: Option<&FxHashSet<&str>>,
1328) -> bool {
1329 if icss_symbols.is_some_and(|symbols| symbols.contains(ident)) {
1330 return true;
1331 }
1332 match property {
1333 PropertyKind::ListStyle => ListStyleReserved.check(ident, TokenFlags::ascii()),
1334 PropertyKind::FontPalette => ident.starts_with("--"),
1335 PropertyKind::Container => ContainerReserved.check(ident, TokenFlags::ascii()),
1336 PropertyKind::Grid => !is_reserved_grid_ident(ident, TokenFlags::ascii()),
1337 PropertyKind::Animation
1338 | PropertyKind::Generic
1339 | PropertyKind::Composes
1340 | PropertyKind::CustomProperty => false,
1341 }
1342}
1343
1344fn is_reserved_container_query_ident(ident: &str, flags: TokenFlags) -> bool {
1345 let mut lowercase = [0; MAX_CSS_KEYWORD_LEN];
1346 let ident = if flags.has_escape() {
1347 decode_css_keyword(ident, &mut lowercase)
1348 } else {
1349 lowercase_ascii_keyword(ident, &mut lowercase)
1350 };
1351 let Some(ident) = ident else {
1352 return false;
1353 };
1354 matches!(ident, "none" | "and" | "or" | "not")
1355}
1356
1357fn parse_grid_template_area_ranges(input: &str, offset: Pos) -> impl Iterator<Item = Range> + '_ {
1358 let bytes = input.as_bytes();
1359 let mut i = 0usize;
1360
1361 std::iter::from_fn(move || {
1362 loop {
1363 while i < bytes.len() && bytes[i].is_ascii_whitespace() {
1364 i += 1;
1365 }
1366 let start = i;
1367 while i < bytes.len() && !bytes[i].is_ascii_whitespace() {
1368 i += 1;
1369 }
1370 if start == i {
1371 return None;
1372 }
1373 if !input[start..i].bytes().all(|c| c == b'.') {
1374 return Some(Range::new(offset + start as Pos, offset + i as Pos));
1375 }
1376 }
1377 })
1378}
1379
1380#[derive(Debug)]
1381struct BlockItemCheckpoint<'s> {
1382 dependencies: [usize; 5],
1383 dashed: usize,
1384 balanced: usize,
1385 mode: Option<ModeCheckpoint<'s>>,
1386}
1387
1388#[derive(Debug)]
1390struct ModeCheckpoint<'s> {
1391 current: Mode,
1392 resulting_global: Option<Pos>,
1393 pure_ignore_pending: bool,
1394 pure_global: Option<Pos>,
1395 composes: Option<ComposesLocalClasses<'s>>,
1396}
1397
1398#[derive(Debug)]
1400struct WarningHandler<'s, W> {
1401 inner: W,
1402 deferred: bool,
1403 pending: SmallVec<[Warning<'s>; 2]>,
1404}
1405
1406impl<'s, W: HandleWarning<'s>> HandleWarning<'s> for WarningHandler<'s, W> {
1407 fn handle_warning(&mut self, warning: Warning<'s>) {
1408 if self.deferred {
1409 self.pending.push(warning);
1410 } else {
1411 self.inner.handle_warning(warning);
1412 }
1413 }
1414}
1415
1416impl<'s, W: HandleWarning<'s>> WarningHandler<'s, W> {
1417 fn finish(&mut self, commit: bool) {
1418 self.deferred = false;
1419 if commit {
1420 for warning in self.pending.drain(..) {
1421 self.inner.handle_warning(warning);
1422 }
1423 } else {
1424 self.pending.clear();
1425 }
1426 }
1427}
1428
1429#[derive(Debug)]
1430pub struct LexDependencies<'s, W> {
1431 dependency_context: DependencyContext<'s>,
1432 mode_data: Option<ModeData<'s>>,
1433 scope: Scope<'s>,
1434 block_nesting_level: u32,
1435 allow_import_at_rule: bool,
1436 balanced: BalancedStack,
1437 is_next_rule_prelude: bool,
1438 scan_context: ScanContext,
1439 selector_square_depth: u32,
1440 selector_fast_forward_enabled: bool,
1441 property_kind: PropertyKind,
1442 in_animation_property: Option<InProperty<AnimationReserved>>,
1443 in_list_style_property: Option<InProperty<ListStyleReserved>>,
1444 in_font_palette_property: Option<InProperty<FontPaletteReserved>>,
1445 in_container_property: Option<InProperty<ContainerReserved>>,
1446 in_grid_property: Option<GridPropertyKind>,
1447 icss_symbols: FxHashSet<&'s str>,
1448 icss_symbol_filter: [u64; 16],
1449 icss_symbol_min_len: usize,
1450 icss_symbol_max_len: usize,
1451 pending_custom_property: Option<Range>,
1452 pending_grid_property: Option<GridPropertyKind>,
1453 handle_warning: WarningHandler<'s, W>,
1454 block_item_checkpoint: Option<BlockItemCheckpoint<'s>>,
1455}
1456
1457impl<'s, W: HandleWarning<'s>> LexDependencies<'s, W> {
1458 pub fn new(handle_warning: W, mode: Mode) -> Self {
1459 Self::with_context(DependencyContext::new(), handle_warning, mode)
1460 }
1461
1462 pub(crate) fn with_context(
1463 dependency_context: DependencyContext<'s>,
1464 handle_warning: W,
1465 mode: Mode,
1466 ) -> Self {
1467 Self {
1468 dependency_context,
1469 mode_data: if mode == Mode::Css {
1470 None
1471 } else {
1472 Some(ModeData::new(mode))
1473 },
1474 scope: Scope::TopLevel,
1475 block_nesting_level: 0,
1476 allow_import_at_rule: true,
1477 balanced: Default::default(),
1478 is_next_rule_prelude: true,
1479 scan_context: ScanContext::TopLevel,
1480 selector_square_depth: 0,
1481 selector_fast_forward_enabled: false,
1482 property_kind: PropertyKind::Generic,
1483 in_animation_property: None,
1484 in_list_style_property: None,
1485 in_font_palette_property: None,
1486 in_container_property: None,
1487 in_grid_property: None,
1488 icss_symbols: Default::default(),
1489 icss_symbol_filter: [0; 16],
1490 icss_symbol_min_len: usize::MAX,
1491 icss_symbol_max_len: 0,
1492 pending_custom_property: None,
1493 pending_grid_property: None,
1494 handle_warning: WarningHandler {
1495 inner: handle_warning,
1496 deferred: false,
1497 pending: SmallVec::new(),
1498 },
1499 block_item_checkpoint: None,
1500 }
1501 }
1502
1503 pub fn dependency_context(&self) -> &DependencyContext<'s> {
1504 &self.dependency_context
1505 }
1506
1507 pub fn into_dependency_context(self) -> DependencyContext<'s> {
1508 self.dependency_context
1509 }
1510
1511 #[inline]
1512 fn set_scan_context(
1513 &mut self,
1514 stream: &mut DependencyTokenStream<'_, 's>,
1515 scan_context: ScanContext,
1516 ) {
1517 if self.scan_context == scan_context {
1518 return;
1519 }
1520 match self.scan_context {
1521 ScanContext::Selector => self.selector_square_depth = 0,
1522 ScanContext::AtRule => stream.reset_at_rule_scan_state(),
1523 ScanContext::GenericValue | ScanContext::SpecialValue(_) => stream.reset_value_scan_states(),
1524 _ => {}
1525 }
1526 self.scan_context = scan_context;
1527 }
1528
1529 pub fn lex_streaming(&mut self, source: &mut DependencyLexer<'s>) {
1531 self.selector_fast_forward_enabled = source.source_end() >= 256;
1532 let mode = self
1533 .mode_data
1534 .as_ref()
1535 .map_or(Mode::Css, ModeData::default_mode);
1536 let source_len = source.source_end() as usize;
1537 source
1538 .visitor_mut()
1539 .reserve(DependencyContext::estimated_dashed_ident_capacity(
1540 source_len, mode,
1541 ));
1542 self
1543 .dependency_context
1544 .reserve_estimated_capacity(source.source_end() as usize, mode);
1545 {
1546 let mut stream = TokenStream::from_lexer(source);
1547 let keep_comments = self.mode_data.as_ref().is_some_and(ModeData::is_pure_mode);
1548 let has_mode = self.mode_data.is_some();
1549 self.update_dashed_ident_collection(&mut stream);
1550 self.lex_streaming_inner(&mut stream, keep_comments, has_mode);
1551 }
1552 self
1553 .dependency_context
1554 .set_dashed_ident_occurrences(source.visitor_mut().take());
1555 }
1556
1557 #[inline]
1558 fn update_dashed_ident_collection(&self, stream: &mut DependencyTokenStream<'_, 's>) {
1559 let enabled = self
1560 .mode_data
1561 .as_ref()
1562 .is_some_and(ModeData::is_current_local_mode);
1563 stream.lexer_mut().visitor_mut().set_enabled(enabled);
1564 }
1565
1566 #[inline(always)]
1567 fn lex_streaming_inner(
1568 &mut self,
1569 stream: &mut DependencyTokenStream<'_, 's>,
1570 keep_comments: bool,
1571 has_mode: bool,
1572 ) {
1573 loop {
1574 if self.scan_context == ScanContext::BlockItem && stream.block_item.is_none() {
1575 let first = stream.peek(keep_comments).token;
1576 if first.kind == TokenKind::Ident {
1577 let custom =
1578 dashed_ident_name_start(stream.slice_trusted(first.range.start, first.range.end))
1579 .is_some();
1580 let collect_dashed = self
1581 .mode_data
1582 .as_ref()
1583 .is_some_and(ModeData::is_current_local_mode);
1584 let property_local = self
1585 .mode_data
1586 .as_ref()
1587 .is_some_and(ModeData::is_property_local_mode);
1588 let (property, pending_grid) = Self::classify_property(
1589 stream.slice_trusted(first.range.start, first.range.end),
1590 first.flags,
1591 property_local,
1592 );
1593 let (prepared, flat_probe_start) = stream.prepare_declaration(
1594 first,
1595 custom,
1596 property == PropertyKind::Generic && self.icss_symbols.is_empty() && !keep_comments,
1597 collect_dashed,
1598 );
1599 if !prepared {
1600 self.block_item_checkpoint = Some(BlockItemCheckpoint {
1601 dependencies: self.dependency_context.checkpoint(),
1602 dashed: stream.lexer_mut().visitor_mut().occurrences.len(),
1603 balanced: self.balanced.len(),
1604 mode: self.mode_data.as_ref().map(|mode| ModeCheckpoint {
1605 current: mode.current,
1606 resulting_global: mode.resulting_global,
1607 pure_ignore_pending: mode.pure_ignore_pending,
1608 pure_global: mode.pure_global,
1609 composes: (property == PropertyKind::Composes)
1610 .then(|| mode.composes_local_classes.clone()),
1611 }),
1612 });
1613 self.handle_warning.deferred = true;
1614 stream.begin_block_item(custom, has_mode, collect_dashed, flat_probe_start);
1615 }
1616 self.property_kind = property;
1617 self.pending_grid_property = pending_grid;
1618 self.pending_custom_property =
1619 (property == PropertyKind::CustomProperty).then_some(first.range);
1620 self.is_next_rule_prelude = false;
1621 self.set_scan_context(stream, ScanContext::DeclarationName);
1622 } else if !matches!(
1623 first.kind,
1624 TokenKind::Comment
1625 | TokenKind::BadComment
1626 | TokenKind::AtKeyword
1627 | TokenKind::Semicolon
1628 | TokenKind::RightCurlyBracket
1629 | TokenKind::Eof
1630 ) {
1631 self.is_next_rule_prelude = true;
1632 if self.block_nesting_level == 0
1633 && let Some(mode_data) = &mut self.mode_data
1634 {
1635 mode_data.composes_local_classes.reset_to_initial();
1636 }
1637 self.set_scan_context(stream, ScanContext::Selector);
1638 }
1639 }
1640 let (item, progress) = stream.next_with_progress(keep_comments);
1641 let token = item.token;
1642 if self.apply_block_item_progress(stream, keep_comments, progress) {
1643 continue;
1644 }
1645 let is_trivia = matches!(token.kind, TokenKind::Comment | TokenKind::BadComment);
1646 let is_animation_important = if token.kind.is_trivia() {
1648 false
1649 } else if let Some(animation) = &mut self.in_animation_property {
1650 std::mem::take(&mut animation.important_pending) && token.kind == TokenKind::Ident && {
1651 let mut normalized = [0; MAX_CSS_KEYWORD_LEN];
1652 decode_css_keyword(
1653 stream.slice_trusted(token.range.start, token.range.end),
1654 &mut normalized,
1655 ) == Some("important")
1656 }
1657 } else {
1658 false
1659 };
1660
1661 if self.scan_context == ScanContext::TopLevel
1662 && self.is_next_rule_prelude
1663 && token.kind != TokenKind::AtKeyword
1664 {
1665 self.set_scan_context(stream, ScanContext::Selector);
1666 }
1667
1668 let mut colon_next = None;
1669 let mut dot_next = None;
1670 if has_mode
1671 && self.scan_context == ScanContext::Selector
1672 && token.kind == TokenKind::Colon
1673 && stream.lexer().could_start_ident_at(token.range.end)
1674 {
1675 let first = stream.peek_significant_skipping_comments(keep_comments);
1676 if first.token.kind != TokenKind::Eof {
1677 colon_next = Some(first);
1678 }
1679 } else if has_mode
1680 && self.scan_context == ScanContext::Selector
1681 && token.kind == TokenKind::Delim
1682 && stream.lexer().byte_at(token.range.start) == Some(b'.')
1683 && stream.lexer().could_start_ident_at(token.range.end)
1684 {
1685 let next = stream.peek_significant_skipping_comments(keep_comments);
1686 if next.token.kind != TokenKind::Eof {
1687 dot_next = Some(next);
1688 }
1689 }
1690
1691 let consumes_subgrammar = token.kind == TokenKind::Function
1692 || (token.kind == TokenKind::Ident && self.property_kind == PropertyKind::Composes);
1693 let mut result = Some(());
1694 match token.kind {
1695 TokenKind::Comment | TokenKind::BadComment => {
1696 result = self.handle_comment(stream.lexer_mut(), token.range.start, token.range.end);
1697 }
1698 TokenKind::WhiteSpace => {}
1699 TokenKind::QuotedString | TokenKind::BadString => {
1700 result = self.handle_string(
1701 stream.lexer_mut(),
1702 token.range.start,
1703 token.range.end,
1704 token.flags,
1705 );
1706 }
1707 TokenKind::Url => {
1708 result = self.handle_url(
1709 stream.lexer_mut(),
1710 token.range.start,
1711 token.range.end,
1712 token.value_range.start,
1713 token.value_range.end,
1714 token.flags,
1715 );
1716 }
1717 TokenKind::Function => {
1718 result = self.handle_function(stream, token.range.start, token.range.end);
1719 }
1720 TokenKind::Ident
1721 if self.scan_context == ScanContext::DeclarationName
1722 && self.property_kind != PropertyKind::Composes => {}
1723 TokenKind::Ident => {
1724 result = self.handle_ident(
1725 stream,
1726 token.range.start,
1727 token.range.end,
1728 token.flags,
1729 is_animation_important,
1730 );
1731 }
1732 TokenKind::AtKeyword
1733 if matches!(
1734 self.scan_context,
1735 ScanContext::GenericValue | ScanContext::SpecialValue(_)
1736 ) => {}
1737 TokenKind::AtKeyword => {
1738 result = self.handle_at_keyword(stream, token.range.start, token.range.end, token.flags);
1739 }
1740 TokenKind::IdHash | TokenKind::Hash
1741 if !has_mode || self.scan_context != ScanContext::Selector => {}
1742 TokenKind::IdHash | TokenKind::Hash => {
1743 let id_end = if token.kind == TokenKind::Hash {
1744 token.range.start + 1
1745 } else {
1746 token.range.end
1747 };
1748 result = self.handle_id(stream.lexer_mut(), token.range.start, id_end, token.flags);
1749 }
1750 TokenKind::Delim
1751 if self.in_animation_property.is_some()
1752 && self.balanced.is_empty()
1753 && stream.byte_at(token.range.start) == Some(b'!') =>
1754 {
1755 if let Some(animation) = &mut self.in_animation_property {
1756 animation.important_pending = true;
1757 }
1758 }
1759 TokenKind::Delim
1760 if (!has_mode || self.scan_context != ScanContext::Selector)
1761 && stream.byte_at(token.range.start) == Some(b'#') => {}
1762 TokenKind::Delim if stream.byte_at(token.range.start) == Some(b'#') => {
1763 result = self.handle_id(
1764 stream.lexer_mut(),
1765 token.range.start,
1766 token.range.end,
1767 token.flags,
1768 );
1769 }
1770 TokenKind::Delim
1771 if (!has_mode || self.scan_context != ScanContext::Selector)
1772 && stream.byte_at(token.range.start) == Some(b'.') => {}
1773 TokenKind::Delim if stream.byte_at(token.range.start) == Some(b'.') => {
1774 let mut class_end = token.range.end;
1775 let mut class_flags = token.flags;
1776 let mut consumes_name = false;
1777 if let Some(next) = dot_next
1778 && next.token.kind == TokenKind::Ident
1779 && next.token.range.start == token.range.end
1780 {
1781 class_end = next.token.range.end;
1782 class_flags = next.token.flags;
1783 consumes_name = true;
1784 }
1785 result = self.handle_class(
1786 stream.lexer_mut(),
1787 token.range.start,
1788 class_end,
1789 class_flags,
1790 );
1791 if consumes_name {
1792 stream.next(keep_comments);
1793 }
1794 }
1795 TokenKind::Delim if self.scan_context == ScanContext::Selector => {
1796 if self.block_nesting_level == 0
1797 && let Some(mode_data) = &mut self.mode_data
1798 {
1799 mode_data.composes_local_classes.invalidate();
1800 }
1801 }
1802 TokenKind::Colon if self.scan_context == ScanContext::DeclarationName => {
1803 result = self.enter_property_value(stream);
1804 }
1805 TokenKind::Colon if !has_mode => {}
1806 TokenKind::Colon => {
1807 if let Some(next) = colon_next.filter(|next| {
1808 matches!(next.token.kind, TokenKind::Ident | TokenKind::Function)
1809 && next.token.range.start == token.range.end
1810 }) {
1811 let (end, function) = (next.token.range.end, next.token.kind == TokenKind::Function);
1812 stream.next(keep_comments);
1813 result = if function {
1814 self.handle_pseudo_function(stream, token.range.start, end)
1815 } else {
1816 self.handle_pseudo_class(stream, token.range.start, end)
1817 };
1818 }
1819 }
1820 TokenKind::LeftSquareBracket if self.scan_context == ScanContext::Selector => {
1821 self.selector_square_depth += 1;
1822 if self.block_nesting_level == 0
1823 && let Some(mode_data) = &mut self.mode_data
1824 {
1825 mode_data.composes_local_classes.invalidate();
1826 }
1827 }
1828 TokenKind::RightSquareBracket if self.scan_context == ScanContext::Selector => {
1829 self.selector_square_depth = self.selector_square_depth.saturating_sub(1);
1830 }
1831 TokenKind::LeftSquareBracket => {
1832 self.balanced.push(
1833 BalancedItem::new_square(token.range.start, token.range.end),
1834 self.mode_data.as_mut(),
1835 );
1836 }
1837 TokenKind::RightSquareBracket
1838 if self
1839 .balanced
1840 .last()
1841 .is_some_and(|last| matches!(last.kind, BalancedItemKind::Square)) =>
1842 {
1843 self.balanced.pop(self.mode_data.as_mut());
1844 }
1845 TokenKind::LeftParenthesis => {
1846 result =
1847 self.handle_left_parenthesis(stream.lexer_mut(), token.range.start, token.range.end);
1848 }
1849 TokenKind::RightParenthesis => {
1850 result = self.handle_right_parenthesis(
1851 stream.lexer_mut(),
1852 item.leading.range.start,
1853 token.range.start,
1854 token.range.end,
1855 );
1856 }
1857 TokenKind::Comma => {
1858 result = self.handle_comma(stream.lexer_mut(), token.range.start, token.range.end);
1859 }
1860 TokenKind::Semicolon | TokenKind::RightCurlyBracket | TokenKind::Eof => {
1861 result = self.handle_recovery_boundary(stream, token);
1862 }
1863 TokenKind::LeftCurlyBracket => {
1864 result = self.handle_left_curly_bracket(stream, token.range.start, token.range.end);
1865 }
1866 _ => {}
1867 }
1868
1869 if consumes_subgrammar
1871 && self.apply_block_item_progress(stream, keep_comments, stream.block_item_progress())
1872 {
1873 continue;
1874 }
1875 if result.is_none() {
1876 return;
1877 }
1878 if has_mode
1881 && (consumes_subgrammar
1882 || matches!(
1883 token.kind,
1884 TokenKind::Colon
1885 | TokenKind::AtKeyword
1886 | TokenKind::RightParenthesis
1887 | TokenKind::RightSquareBracket
1888 | TokenKind::LeftCurlyBracket
1889 | TokenKind::RightCurlyBracket
1890 | TokenKind::Semicolon
1891 | TokenKind::Comma
1892 ))
1893 {
1894 self.update_dashed_ident_collection(stream);
1895 }
1896 match self.scan_context {
1897 ScanContext::Selector if self.selector_fast_forward_enabled => {
1898 self.fast_forward_selector(stream, keep_comments, has_mode);
1899 }
1900 ScanContext::AtRule
1901 if !matches!(self.scope, Scope::InAtImport(_) | Scope::AtImportInvalid) =>
1902 {
1903 self.fast_forward_at_rule(stream, keep_comments);
1904 }
1905 ScanContext::SpecialValue(property) => {
1906 self.fast_forward_special_value(stream, property, keep_comments);
1907 }
1908 ScanContext::GenericValue if !is_trivia => {
1909 self.fast_forward_generic_value(stream, keep_comments);
1910 }
1911 _ => {}
1912 }
1913 }
1914 }
1915
1916 #[inline(always)]
1917 fn apply_block_item_progress(
1918 &mut self,
1919 stream: &mut DependencyTokenStream<'_, 's>,
1920 keep_comments: bool,
1921 mut progress: BlockItemProgress,
1922 ) -> bool {
1923 if progress == BlockItemProgress::ResolveRule {
1924 resolve_block_item(stream, keep_comments);
1925 progress = stream.block_item_progress();
1926 }
1927 matches!(progress, BlockItemProgress::Finished(_))
1928 && self.finish_block_item(stream) != BlockItemKind::Declaration
1929 }
1930
1931 fn finish_block_item(&mut self, stream: &mut DependencyTokenStream<'_, 's>) -> BlockItemKind {
1932 let selected = stream.finish_block_item();
1933 let checkpoint = self
1934 .block_item_checkpoint
1935 .take()
1936 .expect("candidate effects have a checkpoint");
1937 self
1938 .handle_warning
1939 .finish(selected == BlockItemKind::Declaration);
1940 if selected != BlockItemKind::Declaration {
1941 self.dependency_context.rollback(checkpoint.dependencies);
1942 stream
1943 .lexer_mut()
1944 .visitor_mut()
1945 .occurrences
1946 .truncate(checkpoint.dashed);
1947 while self.balanced.len() > checkpoint.balanced {
1950 self.balanced.pop(self.mode_data.as_mut());
1951 }
1952 if let Some(checkpoint) = checkpoint.mode {
1953 let mode = self
1954 .mode_data
1955 .as_mut()
1956 .expect("a mode checkpoint has mode data");
1957 mode.current = checkpoint.current;
1958 mode.resulting_global = checkpoint.resulting_global;
1959 mode.pure_ignore_pending = checkpoint.pure_ignore_pending;
1960 mode.pure_global = checkpoint.pure_global;
1961 if let Some(composes) = checkpoint.composes {
1962 mode.composes_local_classes = composes;
1963 }
1964 }
1965 self.in_animation_property = None;
1966 self.in_list_style_property = None;
1967 self.in_font_palette_property = None;
1968 self.in_container_property = None;
1969 self.in_grid_property = None;
1970 self.pending_custom_property = None;
1971 self.pending_grid_property = None;
1972 self.property_kind = PropertyKind::Generic;
1973 if selected == BlockItemKind::Rule
1974 && self.block_nesting_level == 0
1975 && let Some(mode) = &mut self.mode_data
1976 {
1977 mode.composes_local_classes.reset_to_initial();
1978 }
1979 self.is_next_rule_prelude = selected == BlockItemKind::Rule;
1980 self.set_scan_context(
1981 stream,
1982 if self.is_next_rule_prelude {
1983 ScanContext::Selector
1984 } else {
1985 ScanContext::BlockItem
1986 },
1987 );
1988 }
1989 self.update_dashed_ident_collection(stream);
1990 selected
1991 }
1992
1993 fn icss_symbol_predicate(&self) -> impl FnMut(&str) -> bool + '_ {
1996 |ident| self.contains_icss_symbol(ident)
1997 }
1998
1999 #[inline]
2000 fn fast_forward_selector(
2001 &mut self,
2002 stream: &mut DependencyTokenStream<'_, 's>,
2003 keep_comments: bool,
2004 has_mode: bool,
2005 ) {
2006 let mut square_depth = self.selector_square_depth;
2007 let invalidates_composes = stream.fast_forward_selector_if_buffer_empty(
2008 &mut square_depth,
2009 keep_comments,
2010 has_mode,
2011 self.icss_symbol_predicate(),
2012 is_css_modules_pure_magic_comment,
2013 );
2014 self.selector_square_depth = square_depth;
2015 if invalidates_composes
2016 && self.block_nesting_level == 0
2017 && let Some(mode_data) = &mut self.mode_data
2018 {
2019 mode_data.composes_local_classes.invalidate();
2020 }
2021 }
2022
2023 #[inline]
2024 fn fast_forward_generic_value(
2025 &self,
2026 stream: &mut DependencyTokenStream<'_, 's>,
2027 keep_comments: bool,
2028 ) {
2029 let preserve_strings = matches!(
2030 self.balanced.last(),
2031 Some(last) if matches!(last.kind, BalancedItemKind::Url | BalancedItemKind::ImageSet)
2032 );
2033 let preserve_delimiters = !self.balanced.is_empty();
2034 if self.icss_symbols.is_empty() && !keep_comments {
2035 stream.fast_forward_generic_value_without_candidates_if_buffer_empty(
2036 preserve_strings,
2037 preserve_delimiters,
2038 );
2039 } else {
2040 stream.fast_forward_generic_value_if_buffer_empty(
2041 keep_comments,
2042 preserve_strings,
2043 preserve_delimiters,
2044 self.icss_symbol_predicate(),
2045 is_css_modules_pure_magic_comment,
2046 );
2047 }
2048 }
2049
2050 #[inline]
2051 fn fast_forward_at_rule(&self, stream: &mut DependencyTokenStream<'_, 's>, keep_comments: bool) {
2052 let preserve_strings = matches!(
2053 self.balanced.last(),
2054 Some(last) if matches!(last.kind, BalancedItemKind::Url | BalancedItemKind::ImageSet)
2055 );
2056 let preserve_delimiters = !self.balanced.is_empty();
2057 stream.fast_forward_at_rule_if_buffer_empty(
2058 keep_comments,
2059 preserve_strings,
2060 preserve_delimiters,
2061 self.icss_symbol_predicate(),
2062 is_css_modules_pure_magic_comment,
2063 );
2064 }
2065
2066 #[inline]
2067 fn fast_forward_special_value(
2068 &self,
2069 stream: &mut DependencyTokenStream<'_, 's>,
2070 property: PropertyKind,
2071 keep_comments: bool,
2072 ) {
2073 if property == PropertyKind::Animation {
2076 return;
2077 }
2078 let preserve_strings = property == PropertyKind::Grid
2079 || matches!(
2080 self.balanced.last(),
2081 Some(last) if matches!(last.kind, BalancedItemKind::Url | BalancedItemKind::ImageSet)
2082 );
2083 let preserve_delimiters = !self.balanced.is_empty();
2084 let icss_symbols = (!self.icss_symbols.is_empty()).then_some(&self.icss_symbols);
2085 stream.fast_forward_special_value_if_buffer_empty(
2086 keep_comments,
2087 preserve_strings,
2088 preserve_delimiters,
2089 property,
2090 icss_symbols,
2091 );
2092 }
2093
2094 #[inline]
2095 fn icss_symbol_filter_bit(value: &str) -> (usize, u64) {
2096 let bytes = value.as_bytes();
2097 let len = bytes.len();
2098 let first = bytes.first().copied().unwrap_or_default() as usize;
2099 let middle = bytes.get(len / 2).copied().unwrap_or_default() as usize;
2100 let last = bytes.last().copied().unwrap_or_default() as usize;
2101 let mut hash = len.wrapping_mul(0x9e37_79b1);
2102 hash ^= first.wrapping_mul(0x85eb_ca6b);
2103 hash ^= middle.wrapping_mul(0xc2b2_ae35);
2104 hash ^= last.wrapping_mul(0x27d4_eb2f);
2105 hash ^= hash >> 16;
2106 let bit = hash & 1023;
2107 (bit >> 6, 1u64 << (bit & 63))
2108 }
2109
2110 #[inline]
2111 fn contains_icss_symbol(&self, value: &str) -> bool {
2112 let len = value.len();
2113 if len < self.icss_symbol_min_len || len > self.icss_symbol_max_len {
2114 return false;
2115 }
2116 let (word, bit) = Self::icss_symbol_filter_bit(value);
2117 self.icss_symbol_filter[word] & bit != 0 && self.icss_symbols.contains(value)
2118 }
2119
2120 fn insert_icss_symbol(&mut self, value: &'s str) {
2121 let len = value.len();
2122 self.icss_symbol_min_len = self.icss_symbol_min_len.min(len);
2123 self.icss_symbol_max_len = self.icss_symbol_max_len.max(len);
2124 let (word, bit) = Self::icss_symbol_filter_bit(value);
2125 self.icss_symbol_filter[word] |= bit;
2126 self.icss_symbols.insert(value);
2127 }
2128
2129 fn enter_property_value(&mut self, stream: &mut DependencyTokenStream<'_, 's>) -> Option<()> {
2130 match self.property_kind {
2131 PropertyKind::Animation => self.enter_animation_property(),
2132 PropertyKind::ListStyle => self.enter_list_style_property(),
2133 PropertyKind::FontPalette => self.enter_font_palette_property(),
2134 PropertyKind::Container => self.enter_container_property(),
2135 PropertyKind::Grid => {
2136 if let Some(kind) = self.pending_grid_property.take() {
2137 self.enter_grid_property(kind);
2138 }
2139 }
2140 PropertyKind::CustomProperty => {
2141 if self
2142 .mode_data
2143 .as_ref()
2144 .is_some_and(ModeData::is_property_local_mode)
2145 && let Some(range) = self.pending_custom_property.take()
2146 {
2147 self
2148 .dependency_context
2149 .push_dependency(Dependency::LocalVarDecl {
2150 name: dashed_ident_name(stream.lexer().slice(range.start, range.end)?)?,
2151 range,
2152 });
2153 }
2154 }
2155 PropertyKind::Generic | PropertyKind::Composes => {}
2156 }
2157 self.pending_custom_property = None;
2158 self.pending_grid_property = None;
2159 self.set_scan_context(stream, ScanContext::for_property(self.property_kind));
2160 Some(())
2161 }
2162
2163 fn classify_property(
2164 name: &str,
2165 flags: TokenFlags,
2166 property_local_mode: bool,
2167 ) -> (PropertyKind, Option<GridPropertyKind>) {
2168 if dashed_ident_name_start(name).is_some() {
2169 return if property_local_mode {
2170 (PropertyKind::CustomProperty, None)
2171 } else {
2172 (PropertyKind::Generic, None)
2173 };
2174 }
2175 let mut normalized = [0; MAX_CSS_KEYWORD_LEN];
2176 let name = if flags.has_escape() {
2177 let Some(name) = decode_css_keyword(name, &mut normalized) else {
2178 return (PropertyKind::Generic, None);
2179 };
2180 name
2181 } else {
2182 let Some(name) = lowercase_ascii_keyword(name, &mut normalized) else {
2183 return (PropertyKind::Generic, None);
2184 };
2185 name
2186 };
2187 if matches!(name, "composes" | "compose-with") {
2188 return (PropertyKind::Composes, None);
2189 }
2190 if !property_local_mode {
2191 return (PropertyKind::Generic, None);
2192 }
2193 let unprefixed = strip_vendor_prefix(name).unwrap_or(name);
2194 if matches!(unprefixed, "animation" | "animation-name") {
2195 return (PropertyKind::Animation, None);
2196 }
2197 if matches!(name, "list-style" | "list-style-type") {
2198 return (PropertyKind::ListStyle, None);
2199 }
2200 if name == "font-palette" {
2201 return (PropertyKind::FontPalette, None);
2202 }
2203 if matches!(name, "container" | "container-name") {
2204 return (PropertyKind::Container, None);
2205 }
2206 if let Some(grid) = grid_property_kind(name) {
2207 return (PropertyKind::Grid, Some(grid));
2208 }
2209 (PropertyKind::Generic, None)
2210 }
2211
2212 fn classify_at_rule(name: &str, flags: TokenFlags) -> AtRuleKind {
2213 let mut normalized = [0; MAX_CSS_KEYWORD_LEN];
2214 let name = if flags.has_escape() {
2215 let Some(name) = decode_css_keyword(name, &mut normalized) else {
2216 return AtRuleKind::Other;
2217 };
2218 name
2219 } else {
2220 let Some(name) = lowercase_ascii_keyword(name, &mut normalized) else {
2221 return AtRuleKind::Other;
2222 };
2223 name
2224 };
2225 match name {
2226 "@value" => AtRuleKind::Value,
2227 "@scope" => AtRuleKind::Scope,
2228 "@import" => AtRuleKind::Import,
2229 "@charset" => AtRuleKind::Charset,
2230 "@function" => AtRuleKind::Function,
2231 "@property" => AtRuleKind::Property,
2232 "@namespace" => AtRuleKind::Namespace,
2233 "@keyframes" => AtRuleKind::Keyframes,
2234 "@container" => AtRuleKind::Container,
2235 "@counter-style" => AtRuleKind::CounterStyle,
2236 "@font-palette-values" => AtRuleKind::FontPaletteValues,
2237 _ if name.strip_prefix('@').and_then(strip_vendor_prefix) == Some("keyframes") => {
2238 AtRuleKind::Keyframes
2239 }
2240 _ => AtRuleKind::Other,
2241 }
2242 }
2243
2244 fn get_media(&self, lexer: &DependencyLexer<'s>, start: Pos, end: Pos) -> Option<&'s str> {
2245 let media = lexer.slice(start, end)?;
2246 let bytes = media.as_bytes();
2247 let mut position = 0;
2248 loop {
2249 while position < bytes.len() && bytes[position].is_ascii_whitespace() {
2250 position += 1;
2251 }
2252 if position + 1 < bytes.len() && bytes[position] == b'/' && bytes[position + 1] == b'*' {
2253 let Some(relative_end) = media[position + 2..].find("*/") else {
2254 break;
2255 };
2256 position += relative_end + 4;
2257 continue;
2258 }
2259 break;
2260 }
2261 if position == bytes.len() {
2262 return None;
2263 }
2264 Some(media)
2265 }
2266
2267 fn lex_charset_at_rule(
2268 &mut self,
2269 stream: &mut DependencyTokenStream<'_, 's>,
2270 start: Pos,
2271 ) -> Option<()> {
2272 let string = stream.next_parser_token().token;
2273 if string.kind != TokenKind::QuotedString {
2274 return Some(());
2275 }
2276
2277 let next = stream.next_parser_token().token;
2278 if next.kind == TokenKind::Semicolon {
2279 self
2280 .dependency_context
2281 .push_dependency(Dependency::Charset {
2282 value: stream.slice(string.value_range.start, string.value_range.end)?,
2283 range: Range::new(start, next.range.end),
2284 });
2285 }
2286 Some(())
2287 }
2288
2289 fn enter_animation_property(&mut self) {
2290 self.in_animation_property = Some(InProperty::new(
2291 AnimationReserved::default(),
2292 self.balanced.len(),
2293 ));
2294 }
2295
2296 fn exit_animation_property(&mut self) {
2297 self.in_animation_property = None;
2298 }
2299
2300 fn enter_list_style_property(&mut self) {
2301 self.in_list_style_property = Some(InProperty::new(ListStyleReserved, self.balanced.len()));
2302 }
2303
2304 fn exit_list_style_property(&mut self) {
2305 self.in_list_style_property = None;
2306 }
2307
2308 fn enter_font_palette_property(&mut self) {
2309 self.in_font_palette_property = Some(InProperty::new(FontPaletteReserved, self.balanced.len()));
2310 }
2311
2312 fn exit_font_palette_property(&mut self) {
2313 self.in_font_palette_property = None;
2314 }
2315
2316 fn enter_container_property(&mut self) {
2317 self.in_container_property = Some(InProperty::new(ContainerReserved, self.balanced.len()));
2318 }
2319
2320 fn exit_container_property(&mut self) {
2321 self.in_container_property = None;
2322 }
2323
2324 fn enter_grid_property(&mut self, kind: GridPropertyKind) {
2325 self.in_grid_property = Some(kind);
2326 }
2327
2328 fn exit_grid_property(&mut self) {
2329 self.in_grid_property = None;
2330 }
2331
2332 fn lex_icss_import(&mut self, stream: &mut DependencyTokenStream<'_, 's>) -> Option<()> {
2333 let (start, end) = self.consume_icss_import_path(stream)?;
2334 let right_parenthesis = stream.next_parser_token().token;
2335 if right_parenthesis.kind != TokenKind::RightParenthesis {
2336 self.handle_warning.handle_warning(Warning {
2337 range: Range::new(right_parenthesis.range.start, right_parenthesis.range.end),
2338 kind: WarningKind::Unexpected {
2339 message: "Expected ')' during parsing of ':import()'",
2340 },
2341 });
2342 return Some(());
2343 }
2344 self
2345 .dependency_context
2346 .push_dependency(Dependency::ICSSImportFrom {
2347 path: stream.slice(start, end)?,
2348 });
2349 let left_curly = stream.next_parser_token().token;
2350 if left_curly.kind != TokenKind::LeftCurlyBracket {
2351 self.handle_warning.handle_warning(Warning {
2352 range: Range::new(left_curly.range.start, left_curly.range.end),
2353 kind: WarningKind::Unexpected {
2354 message: "Expected '{' during parsing of ':import()'",
2355 },
2356 });
2357 return Some(());
2358 }
2359 loop {
2360 let first = stream.next_parser_token().token;
2361 if first.kind == TokenKind::Eof {
2362 return None;
2363 }
2364 if first.kind == TokenKind::RightCurlyBracket {
2365 break;
2366 }
2367 let prop_start = first.range.start;
2368 let prop_end = self.consume_icss_export_prop(stream, first)?;
2369 let colon = stream.peek_significant_skipping_comments(true).token;
2370 if colon.kind != TokenKind::Colon {
2371 self.handle_warning.handle_warning(Warning {
2372 range: Range::new(colon.range.start, colon.range.end),
2373 kind: WarningKind::Unexpected {
2374 message: "Expected ':' during parsing of ':import'",
2375 },
2376 });
2377 return Some(());
2378 }
2379 stream.next_parser_token();
2380 let value_start_token = stream.next_parser_token().token;
2381 if value_start_token.kind == TokenKind::Eof {
2382 return None;
2383 }
2384 let value_start = value_start_token.range.start;
2385 let value_end = self.consume_icss_value(stream, value_start_token)?;
2386 let delimiter = stream.next_parser_token().token;
2387 self
2388 .dependency_context
2389 .push_dependency(Dependency::ICSSImportValue {
2390 prop: stream
2391 .slice(prop_start, prop_end)?
2392 .trim_end_matches(is_css_white_space_char),
2393 value: stream
2394 .slice(value_start, value_end)?
2395 .trim_end_matches(is_css_white_space_char),
2396 });
2397 self.insert_icss_symbol(
2398 stream
2399 .slice(prop_start, prop_end)?
2400 .trim_end_matches(is_css_white_space_char),
2401 );
2402 if delimiter.kind == TokenKind::RightCurlyBracket {
2403 break;
2404 }
2405 }
2406 Some(())
2407 }
2408
2409 fn consume_icss_import_path(
2410 &self,
2411 stream: &mut DependencyTokenStream<'_, 's>,
2412 ) -> Option<(Pos, Pos)> {
2413 let first = stream.next_parser_token().token;
2414 if first.kind == TokenKind::Eof {
2415 return None;
2416 }
2417 let start = first.range.start;
2418 let mut end = start;
2419 if first.kind == TokenKind::RightParenthesis {
2420 return Some((start, end));
2421 }
2422 end = first.range.end;
2423 loop {
2424 let token = stream.peek_significant_skipping_comments(true).token;
2425 if token.kind == TokenKind::Eof {
2426 return None;
2427 }
2428 if token.kind == TokenKind::RightParenthesis {
2429 return Some((start, end));
2430 }
2431 stream.next_parser_token();
2432 if first.kind != TokenKind::QuotedString {
2433 end = token.range.end;
2434 }
2435 }
2436 }
2437
2438 fn consume_icss_export_prop(
2439 &self,
2440 stream: &mut DependencyTokenStream<'_, 's>,
2441 first: Token,
2442 ) -> Option<Pos> {
2443 if matches!(
2444 first.kind,
2445 TokenKind::Colon | TokenKind::RightCurlyBracket | TokenKind::Semicolon
2446 ) {
2447 return Some(first.range.start);
2448 }
2449 loop {
2450 let token = stream.peek_parser_token();
2451 if token.token.kind == TokenKind::Eof {
2452 return None;
2453 }
2454 if let Some(first_comment_start) = token.leading.first_comment_start {
2455 return Some(first_comment_start);
2456 }
2457 if matches!(
2458 token.token.kind,
2459 TokenKind::Colon | TokenKind::RightCurlyBracket | TokenKind::Semicolon
2460 ) {
2461 return Some(token.token.range.start);
2462 }
2463 stream.next_parser_token();
2464 }
2465 }
2466
2467 fn consume_icss_value(
2468 &self,
2469 stream: &mut DependencyTokenStream<'_, 's>,
2470 first: Token,
2471 ) -> Option<Pos> {
2472 if matches!(
2473 first.kind,
2474 TokenKind::RightCurlyBracket | TokenKind::Semicolon
2475 ) {
2476 return Some(first.range.start);
2477 }
2478 loop {
2479 let token = stream.peek(true).token;
2480 if token.kind == TokenKind::Eof {
2481 return None;
2482 }
2483 if matches!(
2484 token.kind,
2485 TokenKind::RightCurlyBracket | TokenKind::Semicolon
2486 ) {
2487 return Some(token.range.start);
2488 }
2489 stream.next(true);
2490 }
2491 }
2492
2493 fn lex_value_at_rule(
2494 &mut self,
2495 stream: &mut DependencyTokenStream<'_, 's>,
2496 start: Pos,
2497 ) -> Option<()> {
2498 let input = stream.slice_trusted(0, stream.source_end());
2499 let checkpoint = self
2500 .dependency_context
2501 .value_at_rule_import_items_checkpoint();
2502 let identifiers_checkpoint = self
2503 .dependency_context
2504 .value_at_rule_identifiers_checkpoint();
2505 let mut parser = ValueAtRuleStream::new(input);
2506 loop {
2507 let token = stream.next_parser_token().token;
2508 match token.kind {
2509 TokenKind::Eof => {
2510 self
2511 .dependency_context
2512 .truncate_value_at_rule_identifiers(identifiers_checkpoint);
2513 return None;
2514 }
2515 _ => {
2516 if token.kind == TokenKind::Semicolon && parser.depth == 0 {
2517 parser.params_end = token.range.start;
2518 break;
2519 }
2520 let depth_after = (parser.depth + u32::from(is_open_token(token.kind)))
2521 .saturating_sub(u32::from(is_close_token(token.kind)));
2522 if token.kind == TokenKind::RightCurlyBracket && depth_after == 0 {
2523 parser.params_end = token.range.start;
2524 break;
2525 }
2526 parser.push(&mut self.dependency_context, token);
2527 }
2528 }
2529 }
2530 let at_rule_end = parser.params_end.max(stream.consumed_pos());
2531 let import = parser.last_two().is_some_and(|(penultimate, last)| {
2532 penultimate.kind == TokenKind::Ident
2533 && parser
2534 .input
2535 .get(penultimate.range.start as usize..penultimate.range.end as usize)
2536 .is_some_and(|text| text.eq_ignore_ascii_case("from"))
2537 && parser.from_pos == Some(penultimate.range.start)
2538 && parser
2539 .input
2540 .get(penultimate.range.end as usize..last.range.start as usize)
2541 .is_some_and(trivia_only)
2542 });
2543 if import {
2544 self
2545 .dependency_context
2546 .truncate_value_at_rule_identifiers(identifiers_checkpoint);
2547 let (_, last) = parser
2548 .last_two()
2549 .expect("an import value must end with at least two tokens");
2550 let from = &parser.input[last.range.start as usize..last.range.end as usize];
2551 let item_end = parser.from_prev_end.unwrap_or(parser.item_end);
2552 parser.finish_item(&mut self.dependency_context, item_end);
2553 let items = self
2554 .dependency_context
2555 .finish_value_at_rule_import_items(checkpoint);
2556 if items.is_empty() {
2557 self.handle_warning.handle_warning(Warning {
2558 range: Range::new(start, at_rule_end),
2559 kind: WarningKind::Unexpected {
2560 message: "Broken '@value' at-rule",
2561 },
2562 });
2563 } else {
2564 self
2565 .dependency_context
2566 .push_dependency(Dependency::ICSSImportFrom { path: from });
2567 for index in items.as_usize_range() {
2568 let item = self.dependency_context.value_at_rule_import_item(index);
2569 self
2570 .dependency_context
2571 .push_dependency(Dependency::ICSSImportValue {
2572 prop: item.local_name(),
2573 value: item.import_name(),
2574 });
2575 self.insert_icss_symbol(item.local_name());
2576 self
2577 .dependency_context
2578 .push_dependency(Dependency::ICSSExportValue {
2579 prop: item.local_name(),
2580 value: item.local_name(),
2581 is_at_value: true,
2582 identifiers: DependencyListRange::from_bounds(0, 0),
2583 });
2584 }
2585 }
2586 } else {
2587 self
2588 .dependency_context
2589 .truncate_value_at_rule_import_items(checkpoint);
2590 let local_name;
2591 let raw_start;
2592 let trim_value;
2593 let has_colon;
2594 if let Some(colon) = parser.first_colon {
2595 local_name = &parser.input[parser
2596 .first_significant
2597 .unwrap_or((colon.split, colon.split))
2598 .0 as usize..colon.prev_end as usize];
2599 raw_start = colon.end;
2600 trim_value = parser.first_colon_tokens_after > 0;
2601 has_colon = true;
2602 } else if let Some((first_start, first_end)) = parser.first_significant {
2603 local_name = &parser.input[first_start as usize..first_end as usize];
2604 raw_start = first_end;
2605 trim_value = parser.significant_count > 1;
2606 has_colon = false;
2607 } else {
2608 local_name = "";
2609 raw_start = parser.params_end;
2610 trim_value = false;
2611 has_colon = false;
2612 }
2613 let raw = &parser.input[raw_start as usize..parser.params_end as usize];
2614 let value = if trim_value {
2615 raw.trim_start_matches(is_css_white_space_char)
2616 } else {
2617 raw
2618 };
2619 let value_start = raw_start + (raw.len() - value.len()) as Pos;
2620 let value = if trim_value {
2621 value.trim_end_matches(is_css_white_space_char)
2622 } else {
2623 value
2624 };
2625 if local_name.is_empty() || (!has_colon && value.is_empty()) {
2626 self.handle_warning.handle_warning(Warning {
2627 range: Range::new(start, at_rule_end),
2628 kind: WarningKind::Unexpected {
2629 message: "Broken '@value' at-rule",
2630 },
2631 });
2632 }
2633 if !local_name.is_empty() {
2634 let identifiers = self
2635 .dependency_context
2636 .finish_value_at_rule_identifiers(identifiers_checkpoint, value_start);
2637 self
2638 .dependency_context
2639 .push_dependency(Dependency::ICSSExportValue {
2640 prop: local_name,
2641 value,
2642 is_at_value: true,
2643 identifiers,
2644 });
2645 self.insert_icss_symbol(local_name);
2646 } else {
2647 self
2648 .dependency_context
2649 .truncate_value_at_rule_identifiers(identifiers_checkpoint);
2650 }
2651 }
2652 self
2653 .dependency_context
2654 .push_dependency(Dependency::Replace {
2655 content: "",
2656 range: Range::new(start, at_rule_end),
2657 });
2658 Some(())
2659 }
2660
2661 fn lex_icss_export(&mut self, stream: &mut DependencyTokenStream<'_, 's>) -> Option<()> {
2662 let left_curly = stream.next_parser_token().token;
2663 if left_curly.kind != TokenKind::LeftCurlyBracket {
2664 self.handle_warning.handle_warning(Warning {
2665 range: Range::new(left_curly.range.start, left_curly.range.end),
2666 kind: WarningKind::Unexpected {
2667 message: "Expected '{' during parsing of ':export'",
2668 },
2669 });
2670 return Some(());
2671 }
2672 loop {
2673 let first = stream.next_parser_token().token;
2674 if first.kind == TokenKind::Eof {
2675 return None;
2676 }
2677 if first.kind == TokenKind::RightCurlyBracket {
2678 break;
2679 }
2680 let prop_start = first.range.start;
2681 let prop_end = self.consume_icss_export_prop(stream, first)?;
2682 let colon = stream.peek_significant_skipping_comments(true).token;
2683 if colon.kind != TokenKind::Colon {
2684 self.handle_warning.handle_warning(Warning {
2685 range: Range::new(colon.range.start, colon.range.end),
2686 kind: WarningKind::Unexpected {
2687 message: "Expected ':' during parsing of ':export'",
2688 },
2689 });
2690 return Some(());
2691 }
2692 stream.next_parser_token();
2693 let value_start_token = stream.next_parser_token().token;
2694 if value_start_token.kind == TokenKind::Eof {
2695 return None;
2696 }
2697 let value_start = value_start_token.range.start;
2698 let value_end = self.consume_icss_value(stream, value_start_token)?;
2699 let delimiter = stream.next_parser_token().token;
2700 let value = stream
2701 .slice(value_start, value_end)?
2702 .trim_end_matches(is_css_white_space_char);
2703 self
2704 .dependency_context
2705 .push_dependency(Dependency::ICSSExportValue {
2706 prop: stream
2707 .slice(prop_start, prop_end)?
2708 .trim_end_matches(is_css_white_space_char),
2709 value,
2710 is_at_value: false,
2711 identifiers: DependencyListRange::from_bounds(0, 0),
2712 });
2713 self.insert_icss_symbol(
2714 stream
2715 .slice(prop_start, prop_end)?
2716 .trim_end_matches(is_css_white_space_char),
2717 );
2718 if delimiter.kind == TokenKind::RightCurlyBracket {
2719 break;
2720 }
2721 }
2722 Some(())
2723 }
2724
2725 fn lex_local_var(&mut self, stream: &mut DependencyTokenStream<'_, 's>) -> Option<()> {
2726 let name_token = stream.next_parser_token().token;
2727 let start = name_token.range.start;
2728 let raw_name = stream.slice(start, name_token.range.end)?;
2729 let name = if name_token.kind == TokenKind::Ident {
2730 dashed_ident_name(raw_name)
2731 } else {
2732 None
2733 };
2734 let Some(name) = name else {
2735 self.handle_warning.handle_warning(Warning {
2736 kind: WarningKind::Unexpected {
2737 message: "Expected starts with '--' during parsing of 'var()'",
2738 },
2739 range: Range::new(start, (start + 2).min(name_token.range.end)),
2740 });
2741 return Some(());
2742 };
2743 let end = name_token.range.end;
2744 let next = stream.peek_significant_skipping_comments(true).token;
2745 let (from, from_is_global) = if next.kind == TokenKind::Ident
2746 && is_ascii_keyword(stream.slice(next.range.start, next.range.end)?, "from")
2747 {
2748 stream.next_parser_token();
2749 let path_token = stream.peek_significant_skipping_comments(true).token;
2750 let path_start = path_token.range.start;
2751 let path_end = path_token.range.end;
2752 if !matches!(path_token.kind, TokenKind::QuotedString | TokenKind::Ident) {
2753 self.handle_warning.handle_warning(Warning {
2754 range: Range::new(path_start, path_end),
2755 kind: WarningKind::Unexpected {
2756 message: "Expected string or ident during parsing of 'var()'",
2757 },
2758 });
2759 return Some(());
2760 }
2761 stream.next_parser_token();
2762 let path = stream.slice(path_start, path_end)?;
2763 (
2764 Some(path),
2765 path_token.kind == TokenKind::Ident && path == "global",
2766 )
2767 } else {
2768 (None, false)
2769 };
2770 if from_is_global {
2771 let name_start = dashed_ident_name_start(raw_name)?;
2772 stream
2773 .lexer_mut()
2774 .visitor_mut()
2775 .discard_last(Range::new(start + name_start as Pos, end));
2776 }
2777 self
2778 .dependency_context
2779 .push_dependency(Dependency::LocalVar {
2780 name,
2781 range: Range::new(start, end),
2782 from,
2783 from_is_global,
2784 });
2785 Some(())
2786 }
2787
2788 fn lex_local_dashed_ident_decl(
2789 &mut self,
2790 stream: &mut DependencyTokenStream<'_, 's>,
2791 local_decl_dependency: impl FnOnce(&'s str, Range) -> Dependency<'s>,
2792 dashed_warning: impl FnOnce(Range) -> Warning<'s>,
2793 left_curly_warning: impl FnOnce(Range) -> Warning<'s>,
2794 ) -> Option<()> {
2795 let name_token = stream.next_parser_token().token;
2796 let start = name_token.range.start;
2797 if name_token.kind != TokenKind::Ident
2798 || !stream.slice(start, name_token.range.end)?.starts_with("--")
2799 {
2800 self
2801 .handle_warning
2802 .handle_warning(dashed_warning(Range::new(
2803 start,
2804 (start + 2).min(name_token.range.end),
2805 )));
2806 return Some(());
2807 }
2808 let end = name_token.range.end;
2809 self
2810 .dependency_context
2811 .push_dependency(local_decl_dependency(
2812 dashed_ident_name(stream.slice(start, end)?)?,
2813 Range::new(start, end),
2814 ));
2815 let left_curly = stream.peek_significant_skipping_comments(true).token;
2816 if left_curly.kind != TokenKind::LeftCurlyBracket {
2817 self
2818 .handle_warning
2819 .handle_warning(left_curly_warning(Range::new(
2820 left_curly.range.start,
2821 left_curly.range.end,
2822 )));
2823 return Some(());
2824 }
2825 Some(())
2826 }
2827
2828 fn lex_local_keyframes_decl(&mut self, stream: &mut DependencyTokenStream<'_, 's>) -> Option<()> {
2829 let mut is_function = false;
2830 let first = stream.next_parser_token().token;
2831 let name_token = if first.kind == TokenKind::Colon {
2832 let pseudo_start = first.range.start;
2833 let pseudo_name = stream.next_parser_token().token;
2834 let pseudo_end = if matches!(pseudo_name.kind, TokenKind::Ident | TokenKind::Function) {
2835 pseudo_name.range.end
2836 } else {
2837 first.range.end
2838 };
2839 let pseudo = stream.slice(pseudo_start, pseudo_end)?;
2840 if pseudo_name.kind == TokenKind::Function {
2841 self.handle_pseudo_function(stream, pseudo_start, pseudo_end)?;
2842 } else if pseudo_name.kind == TokenKind::Ident {
2843 self.handle_pseudo_class(stream, pseudo_start, pseudo_end)?;
2844 }
2845 let mode_data = self
2846 .mode_data
2847 .as_ref()
2848 .expect("CSS Modules mode data must exist while parsing keyframes");
2849 if mode_data.is_pure_mode()
2850 && !mode_data.is_pure_check_disabled()
2851 && (pseudo.eq_ignore_ascii_case(":global(") || pseudo.eq_ignore_ascii_case(":global"))
2852 {
2853 self.handle_warning.handle_warning(Warning {
2854 range: Range::new(pseudo_start, pseudo_end),
2855 kind: WarningKind::NotPure {
2856 message: "'@keyframes :global' is not allowed in pure mode",
2857 },
2858 });
2859 }
2860 is_function =
2861 pseudo.eq_ignore_ascii_case(":local(") || pseudo.eq_ignore_ascii_case(":global(");
2862 if !is_function
2863 && !pseudo.eq_ignore_ascii_case(":local")
2864 && !pseudo.eq_ignore_ascii_case(":global")
2865 {
2866 self.handle_warning.handle_warning(Warning {
2867 range: Range::new(pseudo_start, pseudo_end),
2868 kind: WarningKind::Unexpected {
2869 message: "Expected ':local', ':local()', ':global', or ':global()' during parsing of '@keyframes' name",
2870 }
2871 });
2872 return Some(());
2873 }
2874 stream.next_parser_token().token
2875 } else {
2876 first
2877 };
2878
2879 let start = name_token.range.start;
2880 if name_token.kind != TokenKind::Ident {
2881 self.handle_warning.handle_warning(Warning {
2882 range: Range::new(start, start.saturating_add(2).min(stream.source_end())),
2883 kind: WarningKind::Unexpected {
2884 message: "Expected ident during parsing of '@keyframes' name",
2885 },
2886 });
2887 return Some(());
2888 }
2889 let end = name_token.range.end;
2890 if self
2891 .mode_data
2892 .as_ref()
2893 .expect("CSS Modules mode data must exist while parsing keyframes")
2894 .is_current_local_mode()
2895 {
2896 let name = stream.slice(start, end)?;
2897 self
2898 .dependency_context
2899 .push_dependency(Dependency::LocalKeyframesDecl {
2900 name,
2901 range: Range::new(start, end),
2902 });
2903 }
2904 if is_function {
2905 let right_parenthesis = stream.peek_significant_skipping_comments(true).token;
2906 if right_parenthesis.kind != TokenKind::RightParenthesis {
2907 self.handle_warning.handle_warning(Warning {
2908 range: Range::new(right_parenthesis.range.start, right_parenthesis.range.end),
2909 kind: WarningKind::Unexpected {
2910 message: "Expected ')' during parsing of '@keyframes :local(' or '@keyframes :global('",
2911 },
2912 });
2913 return Some(());
2914 }
2915 stream.next_parser_token();
2916 self
2917 .dependency_context
2918 .push_dependency(Dependency::Replace {
2919 content: "",
2920 range: Range::new(right_parenthesis.range.start, right_parenthesis.range.end),
2921 });
2922 let mode_data = self
2923 .mode_data
2924 .as_mut()
2925 .expect("CSS Modules mode data must exist while leaving a keyframes mode function");
2926 mode_data.inside_mode_function -= 1;
2927 self.balanced.pop_without_moda_data();
2928 }
2929 let left_curly = stream.peek_significant_skipping_comments(true).token;
2930 if left_curly.kind != TokenKind::LeftCurlyBracket {
2931 self.handle_warning.handle_warning(Warning {
2932 range: Range::new(left_curly.range.start, left_curly.range.end),
2933 kind: WarningKind::Unexpected {
2934 message: "Expected '{' during parsing of '@keyframes'",
2935 },
2936 });
2937 return Some(());
2938 }
2939 Some(())
2940 }
2941
2942 fn handle_local_keyframes_dependency(&mut self, lexer: &DependencyLexer<'s>) -> Option<()> {
2943 let animation = self
2944 .in_animation_property
2945 .as_mut()
2946 .expect("animation state must exist while handling an animation dependency");
2947 if let Some(range) = animation.take_rename(self.balanced.len()) {
2948 self
2949 .dependency_context
2950 .push_dependency(Dependency::LocalKeyframes {
2951 name: lexer.slice(range.start, range.end)?,
2952 range,
2953 });
2954 }
2955 animation.reset_reserved();
2956 Some(())
2957 }
2958
2959 fn lex_local_counter_style_decl(
2960 &mut self,
2961 stream: &mut DependencyTokenStream<'_, 's>,
2962 ) -> Option<()> {
2963 let name_token = stream.next_parser_token().token;
2964 let start = name_token.range.start;
2965 if name_token.kind != TokenKind::Ident {
2966 self.handle_warning.handle_warning(Warning {
2967 range: Range::new(start, name_token.range.end),
2968 kind: WarningKind::Unexpected {
2969 message: "Expected ident during parsing of '@counter-style'",
2970 },
2971 });
2972 return Some(());
2973 }
2974 let end = name_token.range.end;
2975 self
2976 .dependency_context
2977 .push_dependency(Dependency::LocalCounterStyleDecl {
2978 name: stream.slice(start, end)?,
2979 range: Range::new(start, end),
2980 });
2981 let left_curly = stream.peek_significant_skipping_comments(true).token;
2982 if left_curly.kind != TokenKind::LeftCurlyBracket {
2983 self.handle_warning.handle_warning(Warning {
2984 range: Range::new(left_curly.range.start, left_curly.range.end),
2985 kind: WarningKind::Unexpected {
2986 message: "Expected '{' during parsing of '@counter-style'",
2987 },
2988 });
2989 return Some(());
2990 }
2991 Some(())
2992 }
2993
2994 fn lex_local_container_at_rule(
2995 &mut self,
2996 stream: &mut DependencyTokenStream<'_, 's>,
2997 ) -> Option<()> {
2998 let name_token = stream.next_parser_token().token;
2999 if name_token.kind == TokenKind::LeftParenthesis {
3000 return Some(());
3001 }
3002 if name_token.kind != TokenKind::Ident {
3003 return Some(());
3004 }
3005 let start = name_token.range.start;
3006 let end = name_token.range.end;
3007 let ident = stream.slice(start, end)?;
3008 if is_reserved_container_query_ident(ident, name_token.flags) {
3009 return Some(());
3010 }
3011 if self
3012 .mode_data
3013 .as_ref()
3014 .expect("CSS Modules mode data must exist while parsing a container")
3015 .is_current_local_mode()
3016 {
3017 self
3018 .dependency_context
3019 .push_dependency(Dependency::LocalContainer {
3020 name: ident,
3021 range: Range::new(start, end),
3022 });
3023 }
3024 Some(())
3025 }
3026
3027 fn lex_local_function_decl(&mut self, stream: &mut DependencyTokenStream<'_, 's>) -> Option<()> {
3028 let mut is_function = false;
3029 let first = stream.next_parser_token().token;
3030 let name_token = if first.kind == TokenKind::Colon {
3031 let pseudo_start = first.range.start;
3032 let pseudo_name = stream.next_parser_token().token;
3033 let pseudo_end = if matches!(pseudo_name.kind, TokenKind::Ident | TokenKind::Function) {
3034 pseudo_name.range.end
3035 } else {
3036 first.range.end
3037 };
3038 let pseudo = stream.slice(pseudo_start, pseudo_end)?;
3039 if pseudo_name.kind == TokenKind::Function {
3040 self.handle_pseudo_function(stream, pseudo_start, pseudo_end)?;
3041 } else if pseudo_name.kind == TokenKind::Ident {
3042 self.handle_pseudo_class(stream, pseudo_start, pseudo_end)?;
3043 }
3044 let mode_data = self
3045 .mode_data
3046 .as_ref()
3047 .expect("CSS Modules mode data must exist while parsing a function");
3048 if mode_data.is_pure_mode()
3049 && !mode_data.is_pure_check_disabled()
3050 && (pseudo.eq_ignore_ascii_case(":global(") || pseudo.eq_ignore_ascii_case(":global"))
3051 {
3052 self.handle_warning.handle_warning(Warning {
3053 range: Range::new(pseudo_start, pseudo_end),
3054 kind: WarningKind::NotPure {
3055 message: "'@function :global' is not allowed in pure mode",
3056 },
3057 });
3058 }
3059 is_function =
3060 pseudo.eq_ignore_ascii_case(":local(") || pseudo.eq_ignore_ascii_case(":global(");
3061 if !is_function
3062 && !pseudo.eq_ignore_ascii_case(":local")
3063 && !pseudo.eq_ignore_ascii_case(":global")
3064 {
3065 self.handle_warning.handle_warning(Warning {
3066 range: Range::new(pseudo_start, pseudo_end),
3067 kind: WarningKind::Unexpected {
3068 message:
3069 "Expected ':local', ':local()', ':global', or ':global()' during parsing of '@function' name",
3070 },
3071 });
3072 return Some(());
3073 }
3074 stream.next_parser_token().token
3075 } else {
3076 first
3077 };
3078
3079 let name_range = if name_token.kind == TokenKind::Function {
3080 name_token.value_range
3081 } else {
3082 name_token.range
3083 };
3084 let start = name_range.start;
3085 let end = name_range.end;
3086 let name = stream.slice_trusted(start, end);
3087 if name_token.kind != TokenKind::Ident && name_token.kind != TokenKind::Function
3088 || !name.starts_with("--")
3089 {
3090 self.handle_warning.handle_warning(Warning {
3091 range: Range::new(start, start.saturating_add(2).min(stream.source_end())),
3092 kind: WarningKind::Unexpected {
3093 message: "Expected starts with '--' during parsing of '@function' name",
3094 },
3095 });
3096 return Some(());
3097 }
3098 if self
3099 .mode_data
3100 .as_ref()
3101 .expect("CSS Modules mode data must exist while parsing a function")
3102 .is_current_local_mode()
3103 {
3104 self
3105 .dependency_context
3106 .push_dependency(Dependency::LocalFunctionDecl {
3107 name: dashed_ident_name(stream.slice(start, end)?)?,
3108 range: Range::new(start, end),
3109 });
3110 }
3111
3112 if is_function {
3113 let right_parenthesis = stream.peek_significant_skipping_comments(true).token;
3114 if right_parenthesis.kind != TokenKind::RightParenthesis {
3115 self.handle_warning.handle_warning(Warning {
3116 range: Range::new(right_parenthesis.range.start, right_parenthesis.range.end),
3117 kind: WarningKind::Unexpected {
3118 message: "Expected ')' during parsing of '@function :local(' or '@function :global('",
3119 },
3120 });
3121 return Some(());
3122 }
3123 stream.next_parser_token();
3124 self
3125 .dependency_context
3126 .push_dependency(Dependency::Replace {
3127 content: "",
3128 range: Range::new(right_parenthesis.range.start, right_parenthesis.range.end),
3129 });
3130 let mode_data = self
3131 .mode_data
3132 .as_mut()
3133 .expect("CSS Modules mode data must exist while leaving a function mode function");
3134 mode_data.inside_mode_function -= 1;
3135 self.balanced.pop_without_moda_data();
3136 }
3137
3138 if name_token.kind == TokenKind::Function {
3139 return Some(());
3140 }
3141 let left_parenthesis = stream.peek_significant_skipping_comments(true).token;
3142 if left_parenthesis.kind != TokenKind::LeftParenthesis {
3143 self.handle_warning.handle_warning(Warning {
3144 range: Range::new(left_parenthesis.range.start, left_parenthesis.range.end),
3145 kind: WarningKind::Unexpected {
3146 message: "Expected '(' during parsing of '@function'",
3147 },
3148 });
3149 }
3150 Some(())
3151 }
3152
3153 fn handle_local_counter_style_dependency(&mut self, lexer: &DependencyLexer<'s>) -> Option<()> {
3154 let list_style = self
3155 .in_list_style_property
3156 .as_mut()
3157 .expect("list-style state must exist while handling a counter-style dependency");
3158 if let Some(range) = list_style.take_rename(self.balanced.len()) {
3159 self
3160 .dependency_context
3161 .push_dependency(Dependency::LocalCounterStyle {
3162 name: lexer.slice(range.start, range.end)?,
3163 range,
3164 });
3165 }
3166 Some(())
3167 }
3168
3169 fn handle_local_font_palette_dependency(&mut self, lexer: &DependencyLexer<'s>) -> Option<()> {
3170 let font_palette = self
3171 .in_font_palette_property
3172 .as_mut()
3173 .expect("font-palette state must exist while handling a font-palette dependency");
3174 if let Some(range) = font_palette.take_rename(self.balanced.len()) {
3175 self
3176 .dependency_context
3177 .push_dependency(Dependency::LocalFontPalette {
3178 name: dashed_ident_name(lexer.slice(range.start, range.end)?)?,
3179 range,
3180 });
3181 }
3182 Some(())
3183 }
3184
3185 fn lex_composes(
3186 &mut self,
3187 stream: &mut DependencyTokenStream<'_, 's>,
3188 local_classes: SmallVec<[&'s str; 2]>,
3189 start: Pos,
3190 ) -> Option<()> {
3191 let colon = stream.peek_significant_skipping_comments(true).token;
3192 if colon.kind != TokenKind::Colon {
3193 return Some(());
3194 }
3195 stream.next_parser_token();
3196 let mut replacement_end = colon.range.end;
3197 loop {
3198 let first = stream.peek_significant_skipping_comments(true).token;
3199 if first.kind == TokenKind::Eof {
3200 break;
3201 }
3202 if first.kind == TokenKind::RightCurlyBracket {
3203 break;
3204 }
3205 if first.kind == TokenKind::Semicolon {
3206 stream.next_parser_token();
3207 replacement_end = first.range.end;
3208 break;
3209 }
3210
3211 let item_start = first.range.start;
3212 let mut item_end = item_start;
3213 let mut names: SmallVec<[&'s str; 2]> = SmallVec::new();
3214 let mut has_from = false;
3215 let mut delimiter = first;
3216 loop {
3217 if matches!(
3218 delimiter.kind,
3219 TokenKind::Comma | TokenKind::Semicolon | TokenKind::RightCurlyBracket
3220 ) {
3221 break;
3222 }
3223
3224 if delimiter.kind == TokenKind::Function
3225 && stream.slice(delimiter.range.start, delimiter.range.end)? == "global("
3226 {
3227 let global_start = delimiter.range.start;
3228 stream.next_parser_token();
3229 let name_token = stream.next_parser_token().token;
3230 let Some(name_range) = ident_like_range(name_token) else {
3231 self.handle_warning.handle_warning(Warning {
3232 range: Range::new(
3233 name_token.range.start,
3234 name_token
3235 .range
3236 .start
3237 .saturating_add(2)
3238 .min(stream.source_end()),
3239 ),
3240 kind: WarningKind::Unexpected {
3241 message: "Expected ident during parsing of 'composes'",
3242 },
3243 });
3244 return Some(());
3245 };
3246 let right_parenthesis = stream.peek_significant_skipping_comments(true).token;
3247 if right_parenthesis.kind != TokenKind::RightParenthesis {
3248 self.handle_warning.handle_warning(Warning {
3249 range: Range::new(right_parenthesis.range.start, right_parenthesis.range.end),
3250 kind: WarningKind::Unexpected {
3251 message: "Expected ')' during parsing of 'composes'",
3252 },
3253 });
3254 return Some(());
3255 }
3256 stream.next_parser_token();
3257 item_end = right_parenthesis.range.end;
3258 self.dependency_context.push_composes(
3259 local_classes.iter().copied(),
3260 std::iter::once(stream.slice(name_range.start, name_range.end)?),
3261 Some("global"),
3262 true,
3263 Range::new(global_start, item_end),
3264 );
3265 delimiter = stream.peek_significant_skipping_comments(true).token;
3266 continue;
3267 }
3268
3269 let Some(name_range) = ident_like_range(delimiter) else {
3270 let name_start = delimiter.range.start;
3271 self.handle_warning.handle_warning(Warning {
3272 range: Range::new(
3273 name_start,
3274 name_start.saturating_add(2).min(stream.source_end()),
3275 ),
3276 kind: WarningKind::Unexpected {
3277 message: "Expected ident during parsing of 'composes'",
3278 },
3279 });
3280 return Some(());
3281 };
3282 let ident = stream.slice(name_range.start, name_range.end)?;
3283 if !names.is_empty() && ident.eq_ignore_ascii_case("from") {
3284 stream.next_parser_token();
3285 let path = stream.peek_significant_skipping_comments(true).token;
3286 if matches!(
3287 path.kind,
3288 TokenKind::QuotedString | TokenKind::Ident | TokenKind::Function
3289 ) {
3290 let path_range = if path.kind == TokenKind::Function {
3291 path.value_range
3292 } else {
3293 path.range
3294 };
3295 item_end = path_range.end;
3296 let from_is_global = path.kind == TokenKind::Ident
3297 && is_ascii_keyword(stream.slice(path_range.start, path_range.end)?, "global");
3298 self.dependency_context.push_composes(
3299 local_classes.iter().copied(),
3300 std::mem::take(&mut names),
3301 Some(stream.slice(path_range.start, path_range.end)?),
3302 from_is_global,
3303 Range::new(item_start, item_end),
3304 );
3305 has_from = true;
3306 stream.next_parser_token();
3307 delimiter = stream.peek_significant_skipping_comments(true).token;
3308 break;
3309 }
3310 names.push(ident);
3311 item_end = name_range.end;
3312 delimiter = path;
3313 continue;
3314 }
3315 names.push(ident);
3316 item_end = name_range.end;
3317 stream.next_parser_token();
3318 delimiter = stream.peek_significant_skipping_comments(true).token;
3319 }
3320
3321 if has_from {
3322 if delimiter.kind == TokenKind::Comma {
3323 stream.next_parser_token();
3324 replacement_end = delimiter.range.end;
3325 continue;
3326 }
3327 if delimiter.kind == TokenKind::Semicolon {
3328 stream.next_parser_token();
3329 replacement_end = delimiter.range.end;
3330 break;
3331 }
3332 if delimiter.kind == TokenKind::RightCurlyBracket {
3333 replacement_end = item_end;
3334 break;
3335 }
3336 replacement_end = item_end;
3337 break;
3338 }
3339
3340 if delimiter.kind == TokenKind::Comma {
3341 if !names.is_empty() {
3342 self.dependency_context.push_composes(
3343 local_classes.iter().copied(),
3344 names,
3345 None,
3346 false,
3347 Range::new(item_start, item_end),
3348 );
3349 }
3350 stream.next_parser_token();
3351 replacement_end = delimiter.range.end;
3352 continue;
3353 }
3354
3355 if delimiter.kind == TokenKind::Semicolon {
3356 if !names.is_empty() {
3357 self.dependency_context.push_composes(
3358 local_classes.iter().copied(),
3359 names,
3360 None,
3361 false,
3362 Range::new(item_start, item_end),
3363 );
3364 }
3365 stream.next_parser_token();
3366 replacement_end = delimiter.range.end;
3367 break;
3368 }
3369
3370 if delimiter.kind == TokenKind::RightCurlyBracket {
3371 if !names.is_empty() {
3372 self.dependency_context.push_composes(
3373 local_classes.iter().copied(),
3374 names,
3375 None,
3376 false,
3377 Range::new(item_start, item_end),
3378 );
3379 }
3380 replacement_end = item_end;
3381 break;
3382 }
3383
3384 self.handle_warning.handle_warning(Warning {
3388 range: Range::new(
3389 delimiter.range.start,
3390 delimiter
3391 .range
3392 .start
3393 .saturating_add(2)
3394 .min(stream.source_end()),
3395 ),
3396 kind: WarningKind::Unexpected {
3397 message: "Expected ident during parsing of 'composes'",
3398 },
3399 });
3400 return Some(());
3401 }
3402 self
3403 .dependency_context
3404 .push_dependency(Dependency::Replace {
3405 content: "",
3406 range: Range::new(start, replacement_end),
3407 });
3408 let end = stream.consumed_pos();
3411 if end > 0 && stream.byte_at(end - 1) == Some(b';') {
3412 let range = Range::new(end - 1, end);
3413 self.handle_recovery_boundary(
3414 stream,
3415 Token::with_flags(TokenKind::Semicolon, range, range, TokenFlags::ascii()),
3416 )?;
3417 }
3418 self.property_kind = PropertyKind::Generic;
3420 self.set_scan_context(stream, ScanContext::BlockItem);
3421 Some(())
3422 }
3423}
3424
3425impl<'s, W: HandleWarning<'s>> LexDependencies<'s, W> {
3426 fn magic_comments_before(lexer: &DependencyLexer<'s>, start: Pos) -> Option<&'s str> {
3427 let input = lexer.slice(0, start)?;
3428 let range = preceding_comment_range(input)?;
3429 lexer.slice(range.start, range.end)
3430 }
3431
3432 fn handle_comment(
3433 &mut self,
3434 lexer: &mut DependencyLexer<'s>,
3435 start: Pos,
3436 end: Pos,
3437 ) -> Option<()> {
3438 let Some(mode_data) = &mut self.mode_data else {
3439 return Some(());
3440 };
3441 if !mode_data.is_pure_mode() || end < start + 4 {
3442 return Some(());
3443 }
3444
3445 let content = lexer.slice(start + 2, end - 2)?;
3446 if is_css_modules_magic_comment(content, "cssmodules-pure-ignore") {
3447 mode_data.mark_pure_ignore();
3448 } else if matches!(self.scope, Scope::TopLevel)
3449 && self.block_nesting_level == 0
3450 && is_css_modules_magic_comment(content, "cssmodules-pure-no-check")
3451 {
3452 mode_data.mark_pure_no_check();
3453 }
3454 Some(())
3455 }
3456
3457 fn handle_url(
3458 &mut self,
3459 lexer: &mut DependencyLexer<'s>,
3460 start: Pos,
3461 end: Pos,
3462 content_start: Pos,
3463 content_end: Pos,
3464 flags: TokenFlags,
3465 ) -> Option<()> {
3466 let value = lexer.slice(content_start, content_end)?;
3467 let can_be_dependency = match &self.scope {
3468 Scope::InAtImport(import_data) => !import_data.in_supports(),
3469 Scope::InBlock => true,
3470 _ => false,
3471 };
3472 let magic_comments = can_be_dependency
3473 .then(|| Self::magic_comments_before(lexer, start))
3474 .flatten();
3475 match self.scope {
3476 Scope::InAtImport(ref mut import_data) => {
3477 if import_data.in_supports() {
3478 return Some(());
3479 }
3480 if import_data.url.is_some() {
3481 self.handle_warning.handle_warning(Warning {
3482 range: Range::new(import_data.start, end),
3483 kind: WarningKind::DuplicateUrl {
3484 when: lexer.slice(import_data.start, end)?,
3485 },
3486 });
3487 return Some(());
3488 }
3489 import_data.prelude.push(ImportPreludeNode::Url {
3490 range: Range::new(start, end),
3491 });
3492 import_data.url = Some(value);
3493 import_data.url_flags = flags;
3494 import_data.url_range = Some(Range::new(start, end));
3495 import_data.magic_comments = magic_comments;
3496 }
3497 Scope::InBlock => {
3498 self.dependency_context.push_dependency(Dependency::Url {
3499 request: value,
3500 range: Range::new(start, end),
3501 kind: UrlRangeKind::Function,
3502 magic_comments,
3503 });
3504 }
3505 _ => {}
3506 }
3507 Some(())
3508 }
3509
3510 fn handle_string(
3511 &mut self,
3512 lexer: &mut DependencyLexer<'s>,
3513 start: Pos,
3514 end: Pos,
3515 flags: TokenFlags,
3516 ) -> Option<()> {
3517 let inside_url = matches!(
3518 self.balanced.last(),
3519 Some(last) if matches!(last.kind, BalancedItemKind::Url)
3520 );
3521 let can_be_dependency = match &self.scope {
3522 Scope::InAtImport(import_data) => {
3523 !import_data.in_supports() && (inside_url || import_data.url.is_none())
3524 }
3525 Scope::InBlock => matches!(
3526 self.balanced.last(),
3527 Some(last) if matches!(last.kind, BalancedItemKind::Url | BalancedItemKind::ImageSet)
3528 ),
3529 _ => false,
3530 };
3531 let mut magic_comments = can_be_dependency
3532 .then(|| Self::magic_comments_before(lexer, start))
3533 .flatten();
3534 if magic_comments.is_none()
3535 && let Some(range) = self.balanced.last().and_then(|item| item.magic_comments)
3536 {
3537 magic_comments = lexer.slice(range.start, range.end);
3538 }
3539 match self.scope {
3540 Scope::InAtImport(ref mut import_data) => {
3541 if import_data.in_supports() {
3543 return Some(());
3544 }
3545 if !inside_url && import_data.url.is_some() {
3547 return Some(());
3548 }
3549
3550 if inside_url && import_data.url.is_some() {
3551 self.handle_warning.handle_warning(Warning {
3552 range: Range::new(import_data.start, end),
3553 kind: WarningKind::DuplicateUrl {
3554 when: lexer.slice(import_data.start, end)?,
3555 },
3556 });
3557 return Some(());
3558 }
3559
3560 let value = lexer.slice(start + 1, end - 1)?;
3561 import_data.url = Some(value);
3562 import_data.url_flags = flags;
3563 import_data.magic_comments = magic_comments;
3564 if !inside_url {
3566 import_data.prelude.push(ImportPreludeNode::Url {
3567 range: Range::new(start, end),
3568 });
3569 import_data.url_range = Some(Range::new(start, end));
3570 }
3571 }
3572 Scope::InBlock => {
3573 if let Some(mode_data) = &self.mode_data
3574 && mode_data.is_property_local_mode()
3575 && matches!(
3576 self.in_grid_property,
3577 Some(GridPropertyKind::TemplateLike | GridPropertyKind::TemplateAreas)
3578 )
3579 {
3580 for range in parse_grid_template_area_ranges(lexer.slice(start + 1, end - 1)?, start + 1)
3581 {
3582 self
3583 .dependency_context
3584 .push_dependency(Dependency::LocalGridDecl {
3585 name: lexer.slice(range.start, range.end)?,
3586 range,
3587 });
3588 }
3589 }
3590 let Some(last) = self.balanced.last() else {
3591 return Some(());
3592 };
3593 let kind = match last.kind {
3594 BalancedItemKind::Url => UrlRangeKind::String,
3595 BalancedItemKind::ImageSet => UrlRangeKind::Function,
3596 _ => return Some(()),
3597 };
3598 let value = lexer.slice(start + 1, end - 1)?;
3599 self.dependency_context.push_dependency(Dependency::Url {
3600 request: value,
3601 range: Range::new(start, end),
3602 kind,
3603 magic_comments,
3604 });
3605 }
3606 _ => {}
3607 }
3608 Some(())
3609 }
3610
3611 fn handle_at_keyword(
3612 &mut self,
3613 stream: &mut DependencyTokenStream<'_, 's>,
3614 start: Pos,
3615 end: Pos,
3616 flags: TokenFlags,
3617 ) -> Option<()> {
3618 let name = stream.slice_trusted(start, end);
3619 let kind = Self::classify_at_rule(name, flags);
3620 self.set_scan_context(stream, ScanContext::AtRule);
3621 if kind == AtRuleKind::Namespace {
3622 self.scope = Scope::AtNamespaceInvalid;
3623 self.handle_warning.handle_warning(Warning {
3624 range: Range::new(start, end),
3625 kind: WarningKind::NamespaceNotSupportedInBundledCss,
3626 });
3627 } else if kind == AtRuleKind::Import {
3628 if !self.allow_import_at_rule {
3629 self.scope = Scope::AtImportInvalid;
3630 self.handle_warning.handle_warning(Warning {
3631 range: Range::new(start, end),
3632 kind: WarningKind::NotPrecededAtImport,
3633 });
3634 return Some(());
3635 }
3636 self.scope = Scope::InAtImport(ImportData::new(start));
3637 } else if kind == AtRuleKind::Charset {
3638 self.lex_charset_at_rule(stream, start)?;
3639 self.set_scan_context(stream, ScanContext::TopLevel);
3640 self.is_next_rule_prelude = true;
3641 } else if self.mode_data.is_some() {
3642 let mut can_contain_rules = true;
3643 if kind == AtRuleKind::Value {
3644 self.lex_value_at_rule(stream, start)?;
3645 can_contain_rules = false;
3646 self.set_scan_context(stream, ScanContext::TopLevel);
3647 self.is_next_rule_prelude = true;
3648 } else if kind == AtRuleKind::Keyframes {
3649 self.lex_local_keyframes_decl(stream)?;
3650 } else if kind == AtRuleKind::Container {
3651 self.lex_local_container_at_rule(stream)?;
3652 } else if kind == AtRuleKind::Function {
3653 self.lex_local_function_decl(stream)?;
3654 } else if kind == AtRuleKind::Property {
3655 self.lex_local_dashed_ident_decl(
3656 stream,
3657 |name, range| Dependency::LocalPropertyDecl { name, range },
3658 |range| Warning {
3659 range,
3660 kind: WarningKind::Unexpected {
3661 message: "Expected starts with '--' during parsing of '@property'",
3662 },
3663 },
3664 |range| Warning {
3665 range,
3666 kind: WarningKind::Unexpected {
3667 message: "Expected '{' during parsing of '@property'",
3668 },
3669 },
3670 )?;
3671 } else if kind == AtRuleKind::CounterStyle {
3672 self.lex_local_counter_style_decl(stream)?;
3673 } else if kind == AtRuleKind::FontPaletteValues {
3674 self.lex_local_dashed_ident_decl(
3675 stream,
3676 |name, range| Dependency::LocalFontPaletteDecl { name, range },
3677 |range| Warning {
3678 range,
3679 kind: WarningKind::Unexpected {
3680 message: "Expected starts with '--' during parsing of '@font-palette-values'",
3681 },
3682 },
3683 |range| Warning {
3684 range,
3685 kind: WarningKind::Unexpected {
3686 message: "Expected '{' during parsing of '@font-palette-values'",
3687 },
3688 },
3689 )?;
3690 } else {
3691 self.is_next_rule_prelude = kind == AtRuleKind::Scope;
3692 if self.is_next_rule_prelude {
3693 self.set_scan_context(stream, ScanContext::Selector);
3694 }
3695 }
3696
3697 let mode_data = self
3698 .mode_data
3699 .as_mut()
3700 .expect("CSS Modules mode data must exist while handling an at-rule");
3701 if can_contain_rules && self.block_nesting_level == 0 {
3702 mode_data.composes_local_classes.find_at_keyword();
3703 }
3704
3705 if mode_data.is_pure_mode() {
3706 mode_data.pure_global = None;
3707 }
3708 }
3709 Some(())
3710 }
3711
3712 fn finish_property_value(&mut self, lexer: &mut DependencyLexer<'s>, end: Pos) -> Option<()> {
3713 if let Some(mode_data) = &mut self.mode_data {
3714 mode_data.pure_global = Some(end);
3715 if mode_data.is_property_local_mode() {
3716 if self.in_animation_property.is_some() {
3717 self.handle_local_keyframes_dependency(lexer)?;
3718 }
3719 if self.in_list_style_property.is_some() {
3720 self.handle_local_counter_style_dependency(lexer)?;
3721 }
3722 if self.in_font_palette_property.is_some() {
3723 self.handle_local_font_palette_dependency(lexer)?;
3724 }
3725 }
3726 }
3727 self.exit_animation_property();
3728 self.exit_list_style_property();
3729 self.exit_font_palette_property();
3730 self.exit_container_property();
3731 self.exit_grid_property();
3732 self.pending_custom_property = None;
3733 self.pending_grid_property = None;
3734 self.property_kind = PropertyKind::Generic;
3735 Some(())
3736 }
3737
3738 fn handle_recovery_boundary(
3742 &mut self,
3743 stream: &mut DependencyTokenStream<'_, 's>,
3744 token: Token,
3745 ) -> Option<()> {
3746 let nested = self.selector_square_depth != 0
3747 || self
3748 .balanced
3749 .0
3750 .iter()
3751 .any(|item| !item.kind.is_mode_class())
3752 || stream.value_is_nested();
3753 let import_semicolon = token.kind == TokenKind::Semicolon
3754 && matches!(
3755 self.scope,
3756 Scope::InAtImport(_) | Scope::AtImportInvalid | Scope::AtNamespaceInvalid
3757 );
3758 match RecoveryBoundary::at(token.kind, nested && !import_semicolon) {
3759 Some(RecoveryBoundary::Eof) => {
3760 if self.scan_context == ScanContext::Selector
3761 && let Some(unclosed) = self.balanced.last_component()
3762 {
3763 self.handle_warning.handle_warning(Warning {
3764 range: unclosed.range,
3765 kind: WarningKind::InvalidSelector {
3766 message: "Unclosed function or block in selector",
3767 },
3768 });
3769 }
3770 None
3771 }
3772 Some(RecoveryBoundary::Semicolon) => {
3773 stream.reset_value_scan_states();
3774 self.handle_semicolon(stream.lexer_mut(), token.range.start, token.range.end)?;
3775 if import_semicolon {
3776 while self.balanced.pop(self.mode_data.as_mut()).is_some() {}
3779 }
3780 match self.scope {
3781 Scope::TopLevel => {
3782 self.set_scan_context(stream, ScanContext::TopLevel);
3783 self.is_next_rule_prelude = true;
3784 }
3785 Scope::InBlock => self.set_scan_context(stream, ScanContext::BlockItem),
3786 _ => {}
3787 }
3788 Some(())
3789 }
3790 Some(RecoveryBoundary::RightCurly) => {
3791 stream.reset_value_scan_states();
3792 self.handle_right_curly_bracket(stream, token.range.start, token.range.end)
3793 }
3794 None => {
3795 if token.kind == TokenKind::RightCurlyBracket
3796 && self
3797 .balanced
3798 .last()
3799 .is_some_and(|last| matches!(last.kind, BalancedItemKind::Curly))
3800 {
3801 self.balanced.pop(self.mode_data.as_mut());
3802 }
3803 Some(())
3804 }
3805 }
3806 }
3807
3808 fn handle_semicolon(
3809 &mut self,
3810 lexer: &mut DependencyLexer<'s>,
3811 start: Pos,
3812 end: Pos,
3813 ) -> Option<()> {
3814 match self.scope {
3815 Scope::InAtImport(ref import_data) => {
3816 let Some(url) = import_data.url else {
3817 if let Some((name, name_range)) = import_data.prelude.icss_import_url() {
3818 self
3819 .dependency_context
3820 .push_dependency(Dependency::ICSSImportUrl {
3821 name,
3822 range: Range::new(import_data.start, end),
3823 name_range: *name_range,
3824 });
3825 self.scope = Scope::TopLevel;
3826 return Some(());
3827 }
3828 self.handle_warning.handle_warning(Warning {
3829 range: Range::new(import_data.start, end),
3830 kind: WarningKind::ExpectedUrl {
3831 when: lexer.slice(import_data.start, end)?,
3832 },
3833 });
3834 self.scope = Scope::TopLevel;
3835 return Some(());
3836 };
3837 let Some(url_range) = &import_data.url_range else {
3838 self.handle_warning.handle_warning(Warning {
3839 range: Range::new(start, end),
3840 kind: WarningKind::Unexpected {
3841 message: "Unexpected ';' during parsing of '@import url()'",
3842 },
3843 });
3844 self.scope = Scope::TopLevel;
3845 return Some(());
3846 };
3847 if let Some(range) = import_data.prelude.first_non_url_before(url_range) {
3848 self.handle_warning.handle_warning(Warning {
3849 range: *url_range,
3850 kind: WarningKind::ExpectedUrlBefore {
3851 when: lexer.slice(range.start, url_range.end)?,
3852 },
3853 });
3854 self.scope = Scope::TopLevel;
3855 return Some(());
3856 }
3857 let layer = match &import_data.layer {
3858 ImportDataLayer::None => None,
3859 ImportDataLayer::EndLayer { value, range } => {
3860 if url_range.start > range.start {
3861 self.handle_warning.handle_warning(Warning {
3862 range: *url_range,
3863 kind: WarningKind::ExpectedUrlBefore {
3864 when: lexer.slice(range.start, url_range.end)?,
3865 },
3866 });
3867 self.scope = Scope::TopLevel;
3868 return Some(());
3869 }
3870 Some(*value)
3871 }
3872 };
3873 let supports = match &import_data.supports {
3874 ImportDataSupports::None => None,
3875 ImportDataSupports::InSupports => {
3876 self.handle_warning.handle_warning(Warning {
3877 range: Range::new(start, end),
3878 kind: WarningKind::Unexpected {
3879 message: "Unexpected ';' during parsing of 'supports()'",
3880 },
3881 });
3882 None
3883 }
3884 ImportDataSupports::EndSupports { value, range } => {
3885 if url_range.start > range.start {
3886 self.handle_warning.handle_warning(Warning {
3887 range: *url_range,
3888 kind: WarningKind::ExpectedUrlBefore {
3889 when: lexer.slice(range.start, url_range.end)?,
3890 },
3891 });
3892 self.scope = Scope::TopLevel;
3893 return Some(());
3894 }
3895 Some(*value)
3896 }
3897 };
3898 if let Some(layer_range) = import_data.layer_range()
3899 && let Some(supports_range) = import_data.supports_range()
3900 && layer_range.start > supports_range.start
3901 {
3902 self.handle_warning.handle_warning(Warning {
3903 range: *layer_range,
3904 kind: WarningKind::ExpectedLayerBefore {
3905 when: lexer.slice(supports_range.start, layer_range.end)?,
3906 },
3907 });
3908 self.scope = Scope::TopLevel;
3909 return Some(());
3910 }
3911 let last_end = import_data
3912 .supports_range()
3913 .or_else(|| import_data.layer_range())
3914 .unwrap_or(url_range)
3915 .end;
3916 let media = self.get_media(lexer, last_end, start);
3917 self.dependency_context.push_import(
3918 url,
3919 Range::new(import_data.start, end),
3920 layer,
3921 supports,
3922 media,
3923 import_data.magic_comments,
3924 );
3925 self.scope = Scope::TopLevel;
3926 }
3927 Scope::AtImportInvalid | Scope::AtNamespaceInvalid => {
3928 self.scope = Scope::TopLevel;
3929 }
3930 Scope::InBlock => self.finish_property_value(lexer, end)?,
3931 Scope::TopLevel => {
3932 self.is_next_rule_prelude = true;
3933 }
3934 }
3935 Some(())
3936 }
3937
3938 fn handle_function(
3939 &mut self,
3940 stream: &mut DependencyTokenStream<'_, 's>,
3941 start: Pos,
3942 end: Pos,
3943 ) -> Option<()> {
3944 let name = stream.slice_trusted(start, end);
3945 let function = stream.function_kind();
3946 let mut item = BalancedItem::new_function(function, start, end);
3947 if function == FunctionKind::Url {
3948 item.magic_comments = preceding_comment_range(stream.slice_trusted(0, start));
3949 }
3950 let magic_comments = item.magic_comments;
3951 let at_import_top_level =
3952 matches!(self.scope, Scope::InAtImport(_)) && self.balanced.is_empty();
3953 self.balanced.push(item, self.mode_data.as_mut());
3954
3955 if let Scope::InAtImport(ref mut import_data) = self.scope {
3956 if at_import_top_level && function == FunctionKind::Url {
3957 import_data.prelude.push(ImportPreludeNode::Url {
3958 range: Range::new(start, end),
3959 });
3960 import_data.magic_comments =
3961 magic_comments.map(|range| stream.slice_trusted(range.start, range.end));
3962 } else if at_import_top_level && function == FunctionKind::Layer {
3963 import_data.prelude.push(ImportPreludeNode::Layer {
3964 range: Range::new(start, end),
3965 });
3966 } else if at_import_top_level && function == FunctionKind::Supports {
3967 import_data.prelude.push(ImportPreludeNode::Supports {
3968 range: Range::new(start, end),
3969 });
3970 import_data.supports = ImportDataSupports::InSupports;
3971 } else if at_import_top_level {
3972 import_data.prelude.push(ImportPreludeNode::Other {
3973 range: Range::new(start, end),
3974 });
3975 } else if function == FunctionKind::Supports {
3976 import_data.supports = ImportDataSupports::InSupports;
3977 }
3978 }
3979
3980 if let Scope::InAtImport(ref mut import_data) = self.scope {
3981 let layer_end = at_import_top_level && function == FunctionKind::Layer;
3982 let supports_end = function == FunctionKind::Supports;
3983 if layer_end || supports_end {
3984 let Some(close) = stream.fast_forward(TokenKind::RightParenthesis) else {
3985 return Some(());
3986 };
3987 self.balanced.pop(self.mode_data.as_mut());
3988 if layer_end {
3989 import_data.layer = ImportDataLayer::EndLayer {
3990 value: stream.slice(end, close.end.saturating_sub(1))?,
3991 range: Range::new(start, close.end),
3992 };
3993 } else {
3994 import_data.supports = ImportDataSupports::EndSupports {
3995 value: stream.slice(end, close.end.saturating_sub(1))?,
3996 range: Range::new(start, close.end),
3997 };
3998 }
3999 return Some(());
4000 }
4001 }
4002
4003 let Some(mode_data) = &self.mode_data else {
4004 return Some(());
4005 };
4006 if mode_data.is_current_local_mode() && name.starts_with("--") && end > start + 1 {
4007 self
4008 .dependency_context
4009 .push_dependency(Dependency::LocalFunction {
4010 name: dashed_ident_name(stream.slice(start, end - 1)?)?,
4011 range: Range::new(start, end - 1),
4012 });
4013 }
4014 if mode_data.is_current_local_mode() && function == FunctionKind::Var {
4015 self.lex_local_var(stream)?;
4016 }
4017 Some(())
4018 }
4019
4020 fn handle_left_parenthesis(
4021 &mut self,
4022 _: &mut DependencyLexer<'s>,
4023 start: Pos,
4024 end: Pos,
4025 ) -> Option<()> {
4026 self
4027 .balanced
4028 .push(BalancedItem::new_other(start, end), self.mode_data.as_mut());
4029 Some(())
4030 }
4031
4032 fn handle_right_parenthesis(
4033 &mut self,
4034 lexer: &mut DependencyLexer<'s>,
4035 leading_start: Pos,
4036 start: Pos,
4037 end: Pos,
4038 ) -> Option<()> {
4039 if self.balanced.last().is_some_and(|last| {
4040 matches!(
4041 last.kind,
4042 BalancedItemKind::Curly | BalancedItemKind::Square
4043 )
4044 }) {
4045 return Some(());
4046 }
4047 let Some(last) = self.balanced.pop(self.mode_data.as_mut()) else {
4048 return Some(());
4049 };
4050 if let Some(mode_data) = &mut self.mode_data {
4051 let mut is_function = last.kind.is_mode_function();
4052 let mut function_end = last.range.end;
4053 if last.kind.is_mode_class() {
4054 self.balanced.pop_mode_pseudo_class(mode_data);
4055 let popped = self
4056 .balanced
4057 .pop_without_moda_data()
4058 .expect("a mode pseudo-class must have a preceding balanced item");
4059 debug_assert!(!matches!(
4060 popped.kind,
4061 BalancedItemKind::GlobalClass | BalancedItemKind::LocalClass
4062 ));
4063 is_function = popped.kind.is_mode_function();
4064 function_end = popped.range.end;
4065 }
4066 if is_function {
4067 let is_empty = start == function_end || trivia_only(lexer.slice(function_end, start)?);
4068 let replacement_start = if is_empty {
4069 function_end
4070 } else {
4071 leading_start
4072 };
4073 if is_empty {
4074 let maybe_left_parenthesis_start = function_end.saturating_sub(1);
4075 self.handle_warning.handle_warning(Warning {
4076 range: Range::new(maybe_left_parenthesis_start, end),
4077 kind: WarningKind::Unexpected {
4078 message: "':global()' or ':local()' can't be empty",
4079 },
4080 });
4081 }
4082 self
4083 .dependency_context
4084 .push_dependency(Dependency::Replace {
4085 content: "",
4086 range: Range::new(replacement_start, end),
4087 });
4088 }
4089 }
4090 if let Scope::InAtImport(ref mut import_data) = self.scope {
4091 let not_in_supports = !import_data.in_supports();
4092 if matches!(last.kind, BalancedItemKind::Url) && not_in_supports {
4093 import_data.url_range = Some(Range::new(last.range.start, end));
4094 } else if matches!(last.kind, BalancedItemKind::Layer) && not_in_supports {
4095 import_data.layer = ImportDataLayer::EndLayer {
4096 value: lexer.slice(last.range.end, end - 1)?,
4097 range: Range::new(last.range.start, end),
4098 };
4099 } else if matches!(last.kind, BalancedItemKind::Supports) {
4100 import_data.supports = ImportDataSupports::EndSupports {
4101 value: lexer.slice(last.range.end, end - 1)?,
4102 range: Range::new(last.range.start, end),
4103 }
4104 }
4105 }
4106 Some(())
4107 }
4108
4109 fn handle_ident(
4110 &mut self,
4111 stream: &mut DependencyTokenStream<'_, 's>,
4112 start: Pos,
4113 end: Pos,
4114 flags: TokenFlags,
4115 is_animation_important: bool,
4116 ) -> Option<()> {
4117 let ident = stream.slice_trusted(start, end);
4118 if is_animation_important {
4119 return Some(());
4120 }
4121 if matches!(self.scope, Scope::TopLevel | Scope::InBlock)
4124 && matches!(
4125 self.scan_context,
4126 ScanContext::Selector
4127 | ScanContext::GenericValue
4128 | ScanContext::SpecialValue(_)
4129 | ScanContext::AtRule
4130 )
4131 && (self.scan_context != ScanContext::Selector || self.selector_square_depth == 0)
4132 && self.contains_icss_symbol(ident)
4133 {
4134 self
4135 .dependency_context
4136 .push_dependency(Dependency::ICSSSymbol {
4137 name: ident,
4138 range: Range::new(start, end),
4139 });
4140 if matches!(self.scope, Scope::TopLevel)
4141 && let Some(mode_data) = &mut self.mode_data
4142 {
4143 mode_data.composes_local_classes.invalidate();
4144 }
4145 return Some(());
4146 }
4147 match self.scope {
4148 Scope::InBlock => {
4149 let is_declaration_name = self.scan_context == ScanContext::DeclarationName;
4150 if is_declaration_name && self.property_kind != PropertyKind::Composes {
4151 return Some(());
4152 }
4153 let Some(mode_data) = &mut self.mode_data else {
4154 return Some(());
4155 };
4156 if self.scan_context == ScanContext::Selector && self.block_nesting_level == 0 {
4157 mode_data.composes_local_classes.invalidate();
4158 }
4159 if mode_data.is_current_local_mode()
4160 && self
4161 .balanced
4162 .last()
4163 .is_some_and(|last| last.kind.is_mode_function())
4164 && ident.starts_with("--")
4165 && stream.peek_parser_token().token.kind == TokenKind::RightParenthesis
4166 {
4167 self
4168 .dependency_context
4169 .push_dependency(Dependency::LocalFunction {
4170 name: dashed_ident_name(stream.slice(start, end)?)?,
4171 range: Range::new(start, end),
4172 });
4173 return Some(());
4174 }
4175 if mode_data.is_property_local_mode()
4176 && matches!(self.scan_context, ScanContext::SpecialValue(_))
4177 {
4178 if let Some(animation) = &mut self.in_animation_property {
4179 if self.balanced.is_empty() {
4181 animation.set_rename(stream.slice(start, end)?, flags, Range::new(start, end));
4182 }
4183 return Some(());
4184 }
4185
4186 if let Some(list_style) = &mut self.in_list_style_property {
4187 if self.balanced.is_empty() {
4189 list_style.set_rename(stream.slice(start, end)?, flags, Range::new(start, end));
4190 }
4191 return Some(());
4192 }
4193
4194 if let Some(font_palette) = &mut self.in_font_palette_property {
4195 if self.balanced.is_empty()
4197 || matches!(self.balanced.last(), Some(last) if matches!(last.kind, BalancedItemKind::PaletteMix))
4198 {
4199 font_palette.set_rename(stream.slice(start, end)?, flags, Range::new(start, end));
4200 }
4201 return Some(());
4202 }
4203
4204 if let Some(container) = &mut self.in_container_property {
4205 if self.balanced.is_empty() {
4206 container.set_rename(ident, flags, Range::new(start, end));
4207 if let Some(range) = container.take_rename(self.balanced.len()) {
4208 self
4209 .dependency_context
4210 .push_dependency(Dependency::LocalContainerDecl {
4211 name: stream.slice(range.start, range.end)?,
4212 range,
4213 });
4214 }
4215 }
4216 return Some(());
4217 }
4218
4219 if self.in_grid_property.is_some() {
4220 if self.balanced.is_empty() && !is_reserved_grid_ident(ident, flags) {
4221 self
4222 .dependency_context
4223 .push_dependency(Dependency::LocalGrid {
4224 name: ident,
4225 range: Range::new(start, end),
4226 });
4227 }
4228 return Some(());
4229 }
4230 }
4231
4232 if is_declaration_name && self.property_kind == PropertyKind::Composes {
4233 if self.block_nesting_level != 1 {
4234 self.handle_warning.handle_warning(Warning {
4235 range: Range::new(start, end),
4236 kind: WarningKind::UnexpectedComposition {
4237 message: "not allowed in nested rule",
4238 },
4239 });
4240 return Some(());
4241 }
4242 let Some(local_classes) = mode_data
4243 .composes_local_classes
4244 .get_valid_local_classes(stream.lexer())
4245 else {
4246 self.handle_warning.handle_warning(Warning {
4247 range: Range::new(start, end),
4248 kind: WarningKind::UnexpectedComposition {
4249 message: "only allowed when selector is single :local class",
4250 },
4251 });
4252 return Some(());
4253 };
4254 return self.lex_composes(stream, local_classes, start);
4255 }
4256 }
4257 Scope::InAtImport(ref mut import_data) => {
4258 if !self.balanced.is_empty() || import_data.in_supports() {
4259 return Some(());
4260 }
4261
4262 let ident = stream.slice_trusted(start, end);
4263 if ident.eq_ignore_ascii_case("layer") {
4264 import_data.prelude.push(ImportPreludeNode::Layer {
4265 range: Range::new(start, end),
4266 });
4267 import_data.layer = ImportDataLayer::EndLayer {
4268 value: "",
4269 range: Range::new(start, end),
4270 }
4271 } else if import_data.url.is_none() && import_data.prelude.is_empty() {
4272 import_data
4273 .prelude
4274 .push(ImportPreludeNode::IcssUrlCandidate {
4275 name: ident,
4276 range: Range::new(start, end),
4277 });
4278 } else if import_data.url.is_none() {
4279 import_data.prelude.push(ImportPreludeNode::Other {
4280 range: Range::new(start, end),
4281 });
4282 }
4283 }
4284 Scope::TopLevel => {
4285 let Some(mode_data) = &mut self.mode_data else {
4286 return Some(());
4287 };
4288
4289 mode_data.composes_local_classes.invalidate();
4290 }
4291 _ => {}
4292 }
4293 Some(())
4294 }
4295
4296 fn handle_class(
4297 &mut self,
4298 lexer: &mut DependencyLexer<'s>,
4299 start: Pos,
4300 end: Pos,
4301 _flags: TokenFlags,
4302 ) -> Option<()> {
4303 let Some(mode_data) = &mut self.mode_data else {
4304 return Some(());
4305 };
4306 let name = lexer.slice_trusted(start, end);
4307 if name == "." {
4308 self.handle_warning.handle_warning(Warning {
4309 range: Range::new(start, end),
4310 kind: WarningKind::Unexpected {
4311 message: "Invalid class selector syntax",
4312 },
4313 });
4314 return Some(());
4315 }
4316 if mode_data.is_current_local_mode() {
4317 self
4318 .dependency_context
4319 .push_dependency(Dependency::LocalClass {
4320 name,
4321 range: Range::new(start, end),
4322 explicit: mode_data.is_mode_explicit(),
4323 });
4324 if self.block_nesting_level == 0 {
4325 mode_data
4326 .composes_local_classes
4327 .find_local_class(start + 1, end);
4328 }
4329
4330 if mode_data.is_pure_mode() {
4331 mode_data.pure_global = None;
4332 }
4333 }
4334 Some(())
4335 }
4336
4337 fn handle_id(
4338 &mut self,
4339 lexer: &mut DependencyLexer<'s>,
4340 start: Pos,
4341 end: Pos,
4342 _flags: TokenFlags,
4343 ) -> Option<()> {
4344 let Some(mode_data) = &mut self.mode_data else {
4345 return Some(());
4346 };
4347 let name = lexer.slice_trusted(start, end);
4348 if name == "#" {
4349 self.handle_warning.handle_warning(Warning {
4350 range: Range::new(start, end),
4351 kind: WarningKind::Unexpected {
4352 message: "Invalid id selector syntax",
4353 },
4354 });
4355 return Some(());
4356 }
4357 if mode_data.is_current_local_mode() {
4358 self
4359 .dependency_context
4360 .push_dependency(Dependency::LocalId {
4361 name,
4362 range: Range::new(start, end),
4363 explicit: mode_data.is_mode_explicit(),
4364 });
4365
4366 if self.block_nesting_level == 0 {
4367 mode_data.composes_local_classes.invalidate();
4368 }
4369
4370 if mode_data.is_pure_mode() {
4371 mode_data.pure_global = None;
4372 }
4373 }
4374 Some(())
4375 }
4376
4377 fn handle_left_curly_bracket(
4378 &mut self,
4379 stream: &mut DependencyTokenStream<'_, 's>,
4380 start: Pos,
4381 _: Pos,
4382 ) -> Option<()> {
4383 if matches!(self.scope, Scope::InBlock)
4384 && (self.selector_square_depth != 0
4385 || self.balanced.last_component().is_some()
4386 || (self.scan_context != ScanContext::Selector
4387 && matches!(
4388 self.scan_context,
4389 ScanContext::GenericValue | ScanContext::SpecialValue(_)
4390 )))
4391 {
4392 self.balanced.push(
4393 BalancedItem::new_curly(start, start + 1),
4394 self.mode_data.as_mut(),
4395 );
4396 return Some(());
4397 }
4398 match self.scope {
4399 Scope::TopLevel => {
4400 self.allow_import_at_rule = false;
4401 self.scope = Scope::InBlock;
4402 if self.mode_data.is_none()
4403 || matches!(&self.mode_data, Some(mode_data) if !matches!(mode_data.composes_local_classes.is_single, SingleLocalClass::AtKeyword))
4404 {
4405 self.block_nesting_level = 1;
4406 }
4407 }
4408 Scope::InBlock => {
4409 let is_at_rule_block = matches!(
4410 &self.mode_data,
4411 Some(mode_data)
4412 if matches!(mode_data.composes_local_classes.is_single, SingleLocalClass::AtKeyword)
4413 );
4414 if !is_at_rule_block {
4415 self.block_nesting_level += 1;
4416 }
4417 }
4418 _ => return Some(()),
4419 }
4420 let (pure_check_disabled_for_selector, enter_pure_ignored_block) =
4421 if let Some(mode_data) = &self.mode_data {
4422 (
4423 mode_data.is_pure_check_disabled(),
4424 mode_data.pure_ignore_pending,
4425 )
4426 } else {
4427 (false, false)
4428 };
4429 if self.mode_data.is_none() {
4430 self.set_scan_context(stream, ScanContext::BlockItem);
4431 return Some(());
4432 }
4433 if let Some(mode_data) = &mut self.mode_data {
4434 if let Some(pure_global_start) = mode_data
4435 .pure_global
4436 .filter(|_| mode_data.is_pure_mode() && !pure_check_disabled_for_selector)
4437 {
4438 self.handle_warning.handle_warning(Warning {
4439 range: Range::new(pure_global_start, start),
4440 kind: WarningKind::NotPure {
4441 message: "Selector is not pure (pure selectors must contain at least one local class or id)",
4442 }
4443 });
4444 }
4445
4446 if enter_pure_ignored_block {
4447 mode_data.enter_block(self.block_nesting_level);
4448 }
4449
4450 if let Some(resulting_global_start) = mode_data
4451 .resulting_global
4452 .filter(|_| mode_data.is_current_local_mode())
4453 {
4454 self.handle_warning.handle_warning(Warning {
4455 range: Range::new(resulting_global_start, start),
4456 kind: WarningKind::InconsistentModeResult,
4457 });
4458 }
4459 mode_data.resulting_global = None;
4460
4461 self.balanced.update_property_mode(mode_data);
4462 self.balanced.pop_mode_pseudo_class(mode_data);
4463 if self.is_next_rule_prelude && self.block_nesting_level == 0 {
4464 let mode_data = self
4465 .mode_data
4466 .as_mut()
4467 .expect("CSS Modules mode data must exist while finishing a selector");
4468 mode_data.composes_local_classes.reset_to_initial();
4469 }
4470
4471 debug_assert!(
4472 self.balanced.is_empty(),
4473 "balanced should be empty when end of selector"
4474 );
4475 }
4476 self.exit_container_property();
4477 self.exit_grid_property();
4478 self.pending_custom_property = None;
4479 self.pending_grid_property = None;
4480 self.property_kind = PropertyKind::Generic;
4481 self.set_scan_context(stream, ScanContext::BlockItem);
4482 Some(())
4483 }
4484
4485 fn handle_right_curly_bracket(
4486 &mut self,
4487 stream: &mut DependencyTokenStream<'_, 's>,
4488 _: Pos,
4489 end: Pos,
4490 ) -> Option<()> {
4491 if matches!(self.scope, Scope::InBlock) {
4492 self.finish_property_value(stream.lexer_mut(), end)?;
4493 if self.block_nesting_level > 0 {
4494 self.block_nesting_level -= 1;
4495 }
4496 if let Some(mode_data) = &mut self.mode_data {
4497 mode_data.clear_pure_ignore_pending();
4498 mode_data.exit_block(self.block_nesting_level);
4499 }
4500 if self.block_nesting_level == 0 {
4501 self.scope = Scope::TopLevel;
4502 self.set_scan_context(stream, ScanContext::TopLevel);
4503 self.is_next_rule_prelude = true;
4504 if let Some(mode_data) = &mut self.mode_data {
4505 mode_data.composes_local_classes.reset_to_initial();
4506 }
4507 } else {
4508 self.set_scan_context(stream, ScanContext::BlockItem);
4509 }
4510 }
4511 Some(())
4512 }
4513
4514 fn handle_pseudo_function(
4515 &mut self,
4516 stream: &mut DependencyTokenStream<'_, 's>,
4517 start: Pos,
4518 end: Pos,
4519 ) -> Option<()> {
4520 let function = stream.function_kind();
4521 let name = stream.slice_trusted(start, end);
4522 if let Some(mode_data) = &mut self.mode_data {
4523 if name.eq_ignore_ascii_case(":import(") {
4524 self.lex_icss_import(stream);
4525 self
4526 .dependency_context
4527 .push_dependency(Dependency::Replace {
4528 content: "",
4529 range: Range::new(start, stream.consumed_pos()),
4530 });
4531 return Some(());
4532 }
4533 if name.eq_ignore_ascii_case(":global(") || name.eq_ignore_ascii_case(":local(") {
4534 if mode_data.is_inside_mode_function() {
4535 self.handle_warning.handle_warning(Warning {
4536 range: Range::new(start, end),
4537 kind: WarningKind::ExpectedNotInside {
4538 pseudo: stream.slice(start, end)?,
4539 },
4540 });
4541 }
4542
4543 let next = stream.peek_parser_token();
4544 if next.token.kind == TokenKind::Eof {
4545 return None;
4546 }
4547 self
4548 .dependency_context
4549 .push_dependency(Dependency::Replace {
4550 content: "",
4551 range: Range::new(start, next.token.range.start),
4552 });
4553 } else if self.block_nesting_level == 0 {
4554 mode_data.composes_local_classes.invalidate();
4555 }
4556 }
4557 self.balanced.push(
4558 BalancedItem::new_pseudo_function(function, start, end),
4559 self.mode_data.as_mut(),
4560 );
4561 Some(())
4562 }
4563
4564 fn handle_pseudo_class(
4565 &mut self,
4566 stream: &mut DependencyTokenStream<'_, 's>,
4567 start: Pos,
4568 end: Pos,
4569 ) -> Option<()> {
4570 let Some(mode_data) = &mut self.mode_data else {
4571 return Some(());
4572 };
4573 let name = stream.slice_trusted(start, end);
4574 if name.eq_ignore_ascii_case(":global") || name.eq_ignore_ascii_case(":local") {
4575 if mode_data.is_inside_mode_function() {
4576 self.handle_warning.handle_warning(Warning {
4577 range: Range::new(start, end),
4578 kind: WarningKind::ExpectedNotInside {
4579 pseudo: stream.slice(start, end)?,
4580 },
4581 });
4582 }
4583
4584 let next = stream.peek_parser_token();
4585 if next.token.kind == TokenKind::Eof {
4586 return None;
4587 }
4588 if !next.leading.has_whitespace() {
4589 let missing_whitespace = match stream.byte_at(next.token.range.start) {
4590 Some(b'.' | b'#') => true,
4591 Some(b'{') => next.leading.first_comment_start.is_some(),
4592 _ => false,
4593 };
4594 if missing_whitespace {
4595 self.handle_warning.handle_warning(Warning {
4596 range: Range::new(start, end),
4597 kind: WarningKind::Unexpected {
4598 message: "Missing trailing whitespace",
4599 },
4600 });
4601 }
4602 }
4603 self.balanced.push(
4604 BalancedItem::new_mode_class(name.eq_ignore_ascii_case(":local"), start, end),
4605 self.mode_data.as_mut(),
4606 );
4607 self
4608 .dependency_context
4609 .push_dependency(Dependency::Replace {
4610 content: "",
4611 range: Range::new(
4612 start,
4613 next.leading.first_comment_start.unwrap_or(next.leading.end),
4614 ),
4615 });
4616 return Some(());
4617 }
4618 if matches!(self.scope, Scope::TopLevel) && name.eq_ignore_ascii_case(":export") {
4619 self.lex_icss_export(stream)?;
4620 self
4621 .dependency_context
4622 .push_dependency(Dependency::Replace {
4623 content: "",
4624 range: Range::new(start, stream.consumed_pos()),
4625 });
4626 return Some(());
4627 }
4628
4629 if self.block_nesting_level == 0 {
4630 mode_data.composes_local_classes.invalidate();
4631 }
4632 Some(())
4633 }
4634
4635 fn handle_comma(&mut self, lexer: &mut DependencyLexer<'s>, start: Pos, end: Pos) -> Option<()> {
4636 let Some(mode_data) = &mut self.mode_data else {
4637 return Some(());
4638 };
4639
4640 if let Some(pure_global_start) = mode_data
4641 .pure_global
4642 .filter(|_| mode_data.is_pure_mode() && !mode_data.is_pure_check_disabled())
4643 {
4644 self.handle_warning.handle_warning(Warning {
4645 range: Range::new(pure_global_start, start),
4646 kind: WarningKind::NotPure {
4647 message: "Selector is not pure (pure selectors must contain at least one local class or id)",
4648 }
4649 });
4650 }
4651 mode_data.pure_global = Some(end);
4652
4653 if self.block_nesting_level == 0 {
4654 mode_data.composes_local_classes.find_comma(lexer)?;
4655 }
4656
4657 if let Some(resulting_global_start) = mode_data
4658 .resulting_global
4659 .filter(|_| mode_data.is_current_local_mode())
4660 {
4661 self.handle_warning.handle_warning(Warning {
4662 range: Range::new(resulting_global_start, start),
4663 kind: WarningKind::InconsistentModeResult,
4664 });
4665 }
4666
4667 if self.balanced.len() == 1 {
4668 let last = self
4669 .balanced
4670 .last()
4671 .expect("a balanced item must exist when the stack length is one");
4672 let is_local_class = matches!(last.kind, BalancedItemKind::LocalClass);
4673 let is_global_class = matches!(last.kind, BalancedItemKind::GlobalClass);
4674 if is_local_class || is_global_class {
4675 self.balanced.pop_mode_pseudo_class(mode_data);
4676 if mode_data.resulting_global.is_none() && is_global_class {
4677 mode_data.resulting_global = Some(start);
4678 }
4679 }
4680 }
4681
4682 if matches!(self.scope, Scope::InBlock)
4683 && mode_data.is_property_local_mode()
4684 && self.in_animation_property.is_some()
4685 {
4686 self.handle_local_keyframes_dependency(lexer)?;
4687 }
4688
4689 Some(())
4690 }
4691}