Method fmt_compacted_ident

crates/css_lexer/src/source_cursor.rs:263–321

(&self, f: &mut Formatter<'_>)

	}

	fn fmt_compacted_ident(&self, f: &mut Formatter<'_>) -> Result {
		let token = self.token();
		let start = token.leading_len() as usize;
		let end = self.source.len() - token.trailing_len() as usize;
		let source = &self.source[start..end];

		match token.kind() {
			Kind::AtKeyword => f.write_str("@")?,
			Kind::Hash => f.write_str("#")?,
			_ => {}
		}

		let mut chars = source.chars().peekable();
		let mut i = 0;
		let mut char_i = 0;
		while let Some(c) = chars.next() {
			if c == '\0' {
				write!(f, "{}", REPLACEMENT_CHARACTER)?;
				i += 1;
			} else if c == '\\' {
				i += 1;
				let (ch, n) = source[i..].chars().parse_escape_sequence();
				i += n as usize;
				chars = source[i..].chars().peekable();
				let ch = if ch == '\0' { REPLACEMENT_CHARACTER } else { ch };
				// Check if the decoded character is valid at this position unescaped.
				let valid_unescaped = if ch == '-' && char_i == 0 {
					true
				} else if char_i == 0 || (char_i == 1 && source.starts_with('-')) {
					is_ident_start(ch)
				} else {
					is_ident(ch)
				};
				if valid_unescaped {
					write!(f, "{}", ch)?;
				} else if !ch.is_ascii_hexdigit() && !ch.is_ascii_whitespace() && !is_newline(ch) {
					write!(f, "\\{}", ch)?;
				} else {
					write!(f, "\\{:x}", ch as u32)?;
					// A trailing space is needed if the next character is a hex digit
					// or whitespace, to prevent it from being consumed as part of the escape.
					let next_char = chars.peek().copied();
					if next_char.is_some_and(|nc| nc.is_ascii_hexdigit() || nc == ' ' || nc == '\t') {
						f.write_char(' ')?;
					}
				}
			} else {
				write!(f, "{}", c)?;
				i += c.len_utf8();
			}
			char_i += 1;
		}

		if token.kind() == Kind::Function {
			f.write_str("(")?;
		}

		Ok(())