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