Skip to main content

css_module_lexer/
dependencies.rs

1//! Dependency parser and lexer visitor implementation.
2
3use 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/// Collects dashed identifiers while the dependency parser is in local mode.
22#[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/// Token-aligned split of an import item by a top-level colon or `as` ident.
526/// Names are delimited by the surrounding significant tokens, so comments and
527/// whitespace at the split points stay out of the names.
528#[derive(Debug, Clone, Copy)]
529struct ValueAtRuleSplit {
530  split: Pos,
531  end: Pos,
532  prev_end: Pos,
533  next_start: Option<Pos>,
534}
535
536/// Streaming state for a single `@value` at-rule. Tokens are consumed one at a
537/// time; completed import items are written into the [`DependencyContext`] side
538/// table immediately instead of collecting a token buffer first.
539struct 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  /// Re-parses a parenthesized item: the inner content was not streamed
730  /// token-by-token, so it is tokenized once more and split at depth-zero
731  /// commas, mirroring the legacy aligned-token behavior.
732  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  /// Returns the last two significant tokens, or `None` if there are fewer
821  /// than two.
822  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    // Don't rename when we in functions
1049    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            // keywords values
1096            "none" |
1097            // global values
1098            "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            // https://www.w3.org/TR/css-counter-styles-3/#simple-numeric
1154            "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            // https://www.w3.org/TR/css-counter-styles-3/#simple-alphabetic
1183            | "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            // https://www.w3.org/TR/css-counter-styles-3/#simple-symbolic
1193            | "disc"
1194            | "circle"
1195            | "square"
1196            | "disclosure-open"
1197            | "disclosure-closed"
1198            // https://www.w3.org/TR/css-counter-styles-3/#simple-fixed
1199            | "cjk-earthly-branch"
1200            | "cjk-heavenly-stem"
1201            // https://www.w3.org/TR/css-counter-styles-3/#complex-cjk
1202            | "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            // keywords values
1213            | "none"
1214            // global values
1215            | "initial"
1216            | "inherit"
1217            | "unset"
1218            | "revert"
1219            | "revert-layer" => false,
1220            // The first position keyword in the shorthand fills the position
1221            // slot. A later one can be a custom counter style name.
1222            "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
1323/// Decide whether a raw-scanned ident inside a special property value must be
1324/// handed back to the regular tokenizer. The check applies to plain idents and
1325/// function names alike: `url`/`var`/`image-set` and `--`-prefixed functions
1326/// are stopped by the caller's generic dependency-function rule, while any
1327/// other non-reserved function name also stops the scan so the tokenizer can
1328/// push it onto the balanced stack. `icss_symbols` is only consulted for the
1329/// property kinds whose values can reference ICSS symbols.
1330pub(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      // Keep position keywords so the shorthand parser can track their order.
1341      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/// Mode state restored separately from the balanced stack's nesting counters.
1398#[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/// Warnings are external effects too. Hold them only while both grammars live.
1408#[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  /// Drive dependency extraction from the forward token stream.
1539  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      // The `!important` suffix isn't an animation-name candidate.
1656      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      // Subgrammars publish any transitions from the extra tokens they consume.
1879      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      // Only these handlers can change the selector mode. Value atoms keep
1888      // the collection setting established by the preceding mode transition.
1889      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      // Unwind speculative items through the stack so mode nesting counters
1957      // are restored before selector events are replayed.
1958      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  // Keep one closure type across scanner entry points so the generic scanner
2003  // only needs one ICSS-symbol specialization.
2004  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    // An animation name may be any top-level identifier, so the raw
2083    // scanner usually stops immediately. Continue tokenizing directly.
2084    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      // An invalid token was encountered after a name.  The next loop
3402      // iteration would produce the same warning, but keeping the
3403      // cursor at that token preserves the legacy recovery point.
3404      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    // This subgrammar consumes its own semicolon; synchronize through the
3426    // same boundary handler used by the outer parser before the next item.
3427    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    // A final composition may omit its semicolon before the closing brace.
3436    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        // Do not parse URLs in `supports(...)`.
3559        if import_data.in_supports() {
3560          return Some(());
3561        }
3562        // Do not parse other strings if we already have a URL.
3563        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        // For url("inside_url") url_range will determined in right_parenthesis
3582        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  /// Synchronize statement and block state in one place. Inner component
3756  /// delimiters cannot end a declaration; @import retains its legacy recovery
3757  /// at a semicolon even inside malformed url()/supports() functions.
3758  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          // A recovered import must not leave an unfinished function/mode
3794          // stack attached to the next top-level rule.
3795          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    // ICSS references can also occur in selectors and at-rule preludes,
4139    // where the scope is not necessarily a declaration block.
4140    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            // Not inside functions
4197            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            // Not inside functions
4205            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            // Not inside functions or inside palette-mix()
4213            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            // Bracketed explicit lines can share an implicit line's name.
4238            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}