Method consume_ident_sequence

crates/css_lexer/src/private.rs:202–321

(&mut self, atoms: &dyn DynAtomSet)

	}

	fn consume_ident_sequence(&mut self, atoms: &dyn DynAtomSet) -> (u32, bool, bool, bool, u32, bool) {
		let mut dashed_ident = false;
		let mut contains_non_lower_ascii = false;
		let mut contains_escape = false;

		let remaining = self.remaining_bytes();
		if !remaining.is_empty() {
			let bytes = remaining;
			let end = bytes.len();
			let mut i = 0;
			if bytes.len() >= 2 && bytes[0] == b'-' && bytes[1] == b'-' {
				i = 2;
				dashed_ident = true;
			}
			let scan_start = i;
			while i < end {
				let byte = bytes[i];
				if !is_ident_byte(byte) {
					break;
				}
				contains_non_lower_ascii |= byte.wrapping_sub(b'A') < 26;
				i += 1;
			}

			let ascii_len = (i - scan_start) as u32;
			let len = i as u32;
			if ascii_len > 0 {
				let next_byte = if i < end { bytes[i] } else { b' ' };
				if next_byte < 128 && !is_ident_byte(next_byte) && next_byte != b'\\' && next_byte != 0 {
					// SAFETY: the fast path only scans ASCII ident bytes, which are valid UTF-8.
					let ident_str = unsafe { std::str::from_utf8_unchecked(&bytes[..i]) };
					self.advance_n(i);
					let atom_bits =
						if dashed_ident { atoms.str_to_bits(&ident_str[2..]) } else { atoms.str_to_bits(ident_str) };
					return (
						len,
						contains_non_lower_ascii,
						dashed_ident,
						false,
						atom_bits,
						ascii_len == 3 && is_url_ident(ident_str),
					);
				}
			}
		}

		let str = self.remaining_str();
		let mut len: u32 = 0;
		let mut small_ident = SmallStrBuf::<MAX_SMALL_IDENT_SIZE>::new();

		loop {
			let c = self.peek_char();
			if c == EOF && self.at_end() {
				break;
			}
			// Most common case first: lowercase ASCII, digits, or dash (except leading dash)
			if is_ident_ascii_lower_or_digit(c) || (c == '-' && len > 0) {
				self.pos += 1; // ASCII, 1 byte