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