/src/rust-cssparser/src/serializer.rs

Source
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use std::fmt::{self, Write};
use std::str;

#[cfg(feature = "fast_match_byte")]
pub use crate::match_byte;

use super::Token;

/// Trait for things the can serialize themselves in CSS syntax.
pub trait ToCss {
    /// Serialize `self` in CSS syntax, writing to `dest`.
    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
    where
        W: fmt::Write;

    /// Serialize `self` in CSS syntax and return a string.
    ///
    /// (This is a convenience wrapper for `to_css` and probably should not be overridden.)
    #[inline]
    fn to_css_string(&self) -> String {
        let mut s = String::new();
        self.to_css(&mut s).unwrap();
        s
    }
}

#[inline]
fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &mut W) -> fmt::Result
where
    W: fmt::Write,
{
    if value == 0.0 && value.is_sign_negative() {
        // Negative zero. Work around #20596.
        return dest.write_str("-0");
    }
    // NOTE: `value.value >= 0` is true for negative 0 but we've dealt with it above.
    if has_sign && value >= 0.0 {
        dest.write_str("+")?;
    }

    if let Some(v) = int_value {
        return write!(dest, "{}", v);
    }

    let notation = dtoa_short::write(dest, value)?;
    if value.fract() == 0. && !notation.decimal_point && !notation.scientific {
        dest.write_str(".0")?;
    }
    Ok(())
}

impl ToCss for Token<'_> {
    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
    where
        W: fmt::Write,
    {
        match *self {
            Token::Ident(ref value) => serialize_identifier(value, dest)?,
            Token::AtKeyword(ref value) => {
                dest.write_str("@")?;
                serialize_identifier(value, dest)?;
            }
            Token::Hash(ref value) => {
                dest.write_str("#")?;
                serialize_name(value, dest)?;
            }
            Token::IDHash(ref value) => {
                dest.write_str("#")?;
                serialize_identifier(value, dest)?;
            }
            Token::QuotedString(ref value) => serialize_string(value, dest)?,
            Token::UnquotedUrl(ref value) => {
                dest.write_str("url(")?;
                serialize_unquoted_url(value, dest)?;
                dest.write_str(")")?;
            }
            Token::Delim(value) => dest.write_char(value)?,

            Token::Number {
                value,
                int_value,
                has_sign,
            } => write_numeric(value, int_value, has_sign, dest)?,
            Token::Percentage {
                unit_value,
                int_value,
                has_sign,
            } => {
                write_numeric(unit_value * 100., int_value, has_sign, dest)?;
                dest.write_str("%")?;
            }
            Token::Dimension {
                value,
                int_value,
                has_sign,
                ref unit,
            } => {
                write_numeric(value, int_value, has_sign, dest)?;
                // Disambiguate with scientific notation.
                let unit = &**unit;
                // TODO(emilio): This doesn't handle e.g. 100E1m, which gets us
                // an unit of "E1m"...
                if unit == "e" || unit == "E" || unit.starts_with("e-") || unit.starts_with("E-") {
                    dest.write_str("\\65 ")?;
                    serialize_name(&unit[1..], dest)?;
                } else {
                    serialize_identifier(unit, dest)?;
                }
            }

            Token::WhiteSpace(content) => dest.write_str(content)?,
            Token::Comment(content) => {
                dest.write_str("/*")?;
                dest.write_str(content)?;
                dest.write_str("*/")?
            }
            Token::Colon => dest.write_str(":")?,
            Token::Semicolon => dest.write_str(";")?,
            Token::Comma => dest.write_str(",")?,
            Token::IncludeMatch => dest.write_str("~=")?,
            Token::DashMatch => dest.write_str("|=")?,
            Token::PrefixMatch => dest.write_str("^=")?,
            Token::SuffixMatch => dest.write_str("$=")?,
            Token::SubstringMatch => dest.write_str("*=")?,
            Token::CDO => dest.write_str("<!--")?,
            Token::CDC => dest.write_str("-->")?,

            Token::Function(ref name) => {
                serialize_identifier(name, dest)?;
                dest.write_str("(")?;
            }
            Token::ParenthesisBlock => dest.write_str("(")?,
            Token::SquareBracketBlock => dest.write_str("[")?,
            Token::CurlyBracketBlock => dest.write_str("{")?,

            Token::BadUrl(ref contents) => {
                dest.write_str("url(")?;
                dest.write_str(contents)?;
                dest.write_char(')')?;
            }
            Token::BadString(ref value) => {
                // During tokenization, an unescaped newline after a quote causes
                // the token to be a BadString instead of a QuotedString.
                // The BadString token ends just before the newline
                // (which is in a separate WhiteSpace token),
                // and therefore does not have a closing quote.
                dest.write_char('"')?;
                CssStringWriter::new(dest).write_str(value)?;
            }
            Token::CloseParenthesis => dest.write_str(")")?,
            Token::CloseSquareBracket => dest.write_str("]")?,
            Token::CloseCurlyBracket => dest.write_str("}")?,
        }
        Ok(())
    }
}

fn hex_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result
where
    W: fmt::Write,
{
    static HEX_DIGITS: &[u8; 16] = b"0123456789abcdef";
    let b3;
    let b4;
    let bytes = if ascii_byte > 0x0F {
        let high = (ascii_byte >> 4) as usize;
        let low = (ascii_byte & 0x0F) as usize;
        b4 = [b'\\', HEX_DIGITS[high], HEX_DIGITS[low], b' '];
        &b4[..]
    } else {
        b3 = [b'\\', HEX_DIGITS[ascii_byte as usize], b' '];
        &b3[..]
    };
    dest.write_str(unsafe { str::from_utf8_unchecked(bytes) })
}

fn char_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result
where
    W: fmt::Write,
{
    let bytes = [b'\\', ascii_byte];
    dest.write_str(unsafe { str::from_utf8_unchecked(&bytes) })
}

/// Write a CSS identifier, escaping characters as necessary.
pub fn serialize_identifier<W>(mut value: &str, dest: &mut W) -> fmt::Result
where
    W: fmt::Write,
{
    if value.is_empty() {
        return Ok(());
    }

    if let Some(value) = value.strip_prefix("--") {
        dest.write_str("--")?;
        serialize_name(value, dest)
    } else if value == "-" {
        dest.write_str("\\-")
    } else {
        if value.as_bytes()[0] == b'-' {
            dest.write_str("-")?;
            value = &value[1..];
        }
        if let digit @ b'0'..=b'9' = value.as_bytes()[0] {
            hex_escape(digit, dest)?;
            value = &value[1..];
        }
        serialize_name(value, dest)
    }
}

/// Write a CSS name, like a custom property name.
///
/// You should only use this when you know what you're doing, when in doubt,
/// consider using `serialize_identifier`.
pub fn serialize_name<W>(value: &str, dest: &mut W) -> fmt::Result
where
    W: fmt::Write,
{
    let mut chunk_start = 0;
    for (i, b) in value.bytes().enumerate() {
        let escaped = match_byte! { b,
            b'0'..=b'9' | b'A'..=b'Z' | b'a'..=b'z' | b'_' | b'-' => continue,
            b'\0' => Some("\u{FFFD}"),
            b => {
                if !b.is_ascii() {
                    continue;
                }
                None
            },
        };
        dest.write_str(&value[chunk_start..i])?;
        if let Some(escaped) = escaped {
            dest.write_str(escaped)?;
        } else if (b'\x01'..=b'\x1F').contains(&b) || b == b'\x7F' {
            hex_escape(b, dest)?;
        } else {
            char_escape(b, dest)?;
        }
        chunk_start = i + 1;
    }
    dest.write_str(&value[chunk_start..])
}

fn serialize_unquoted_url<W>(value: &str, dest: &mut W) -> fmt::Result
where
    W: fmt::Write,
{
    let mut chunk_start = 0;
    for (i, b) in value.bytes().enumerate() {
        let hex = match_byte! { b,
            b'\0'..=b' ' | b'\x7F' => true,
            b'(' | b')' | b'"' | b'\'' | b'\\' => false,
            _ => continue,
        };
        dest.write_str(&value[chunk_start..i])?;
        if hex {
            hex_escape(b, dest)?;
        } else {
            char_escape(b, dest)?;
        }
        chunk_start = i + 1;
    }
    dest.write_str(&value[chunk_start..])
}

/// Write a double-quoted CSS string token, escaping content as necessary.
pub fn serialize_string<W>(value: &str, dest: &mut W) -> fmt::Result
where
    W: fmt::Write,
{
    dest.write_str("\"")?;
    CssStringWriter::new(dest).write_str(value)?;
    dest.write_str("\"")?;
    Ok(())
}

/// A `fmt::Write` adapter that escapes text for writing as a double-quoted CSS string.
/// Quotes are not included.
///
/// Typical usage:
///
/// ```rust,ignore
/// fn write_foo<W>(foo: &Foo, dest: &mut W) -> fmt::Result where W: fmt::Write {
///     dest.write_str("\"")?;
///     {
///         let mut string_dest = CssStringWriter::new(dest);
///         // Write into string_dest...
///     }
///     dest.write_str("\"")?;
///     Ok(())
/// }
/// ```
pub struct CssStringWriter<'a, W> {
    inner: &'a mut W,
}

impl<'a, W> CssStringWriter<'a, W>
where
    W: fmt::Write,
{
    /// Wrap a text writer to create a `CssStringWriter`.
    pub fn new(inner: &'a mut W) -> CssStringWriter<'a, W> {
        CssStringWriter { inner }
    }
}

impl<W> fmt::Write for CssStringWriter<'_, W>
where
    W: fmt::Write,
{
    fn write_str(&mut self, s: &str) -> fmt::Result {
        let mut chunk_start = 0;
        for (i, b) in s.bytes().enumerate() {
            let escaped = match_byte! { b,
                b'"' => Some("\\\""),
                b'\\' => Some("\\\\"),
                b'\0' => Some("\u{FFFD}"),
                b'\x01'..=b'\x1F' | b'\x7F' => None,
                _ => continue,
            };
            self.inner.write_str(&s[chunk_start..i])?;
            match escaped {
                Some(x) => self.inner.write_str(x)?,
                None => hex_escape(b, self.inner)?,
            };
            chunk_start = i + 1;
        }
        self.inner.write_str(&s[chunk_start..])
    }
}

macro_rules! impl_tocss_for_int {
    ($T: ty) => {
        impl ToCss for $T {
            fn to_css<W>(&self, dest: &mut W) -> fmt::Result
            where
                W: fmt::Write,
            {
                let mut buf = itoa::Buffer::new();
                dest.write_str(buf.format(*self))
            }
        }
    };
}

impl_tocss_for_int!(i8);
impl_tocss_for_int!(u8);
impl_tocss_for_int!(i16);
impl_tocss_for_int!(u16);
impl_tocss_for_int!(i32);
impl_tocss_for_int!(u32);
impl_tocss_for_int!(i64);
impl_tocss_for_int!(u64);

macro_rules! impl_tocss_for_float {
    ($T: ty) => {
        impl ToCss for $T {
            fn to_css<W>(&self, dest: &mut W) -> fmt::Result
            where
                W: fmt::Write,
            {
                dtoa_short::write(dest, *self).map(|_| ())
            }
        }
    };
}

impl_tocss_for_float!(f32);
impl_tocss_for_float!(f64);

/// A category of token. See the `needs_separator_when_before` method.
#[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
pub enum TokenSerializationType {
    /// No token serialization type.
    #[default]
    Nothing,

    /// The [`<whitespace-token>`](https://drafts.csswg.org/css-syntax/#whitespace-token-diagram)
    /// type.
    WhiteSpace,

    /// The [`<at-keyword-token>`](https://drafts.csswg.org/css-syntax/#at-keyword-token-diagram)
    /// type, the "[`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with
    /// the type flag set to 'unrestricted'" type, or the
    /// "[`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type
    /// flag set to 'id'" type.
    AtKeywordOrHash,

    /// The [`<number-token>`](https://drafts.csswg.org/css-syntax/#number-token-diagram) type.
    Number,

    /// The [`<dimension-token>`](https://drafts.csswg.org/css-syntax/#dimension-token-diagram)
    /// type.
    Dimension,

    /// The [`<percentage-token>`](https://drafts.csswg.org/css-syntax/#percentage-token-diagram)
    /// type.
    Percentage,

    /// The [`<url-token>`](https://drafts.csswg.org/css-syntax/#url-token-diagram) or
    /// `<bad-url-token>` type.
    UrlOrBadUrl,

    /// The [`<function-token>`](https://drafts.csswg.org/css-syntax/#function-token-diagram) type.
    Function,

    /// The [`<ident-token>`](https://drafts.csswg.org/css-syntax/#ident-token-diagram) type.
    Ident,

    /// The `-->` [`<CDC-token>`](https://drafts.csswg.org/css-syntax/#CDC-token-diagram) type.
    CDC,

    /// The `|=`
    /// [`<dash-match-token>`](https://drafts.csswg.org/css-syntax/#dash-match-token-diagram) type.
    DashMatch,

    /// The `*=`
    /// [`<substring-match-token>`](https://drafts.csswg.org/css-syntax/#substring-match-token-diagram)
    /// type.
    SubstringMatch,

    /// The `<(-token>` type.
    OpenParen,

    /// The `#` `<delim-token>` type.
    DelimHash,

    /// The `@` `<delim-token>` type.
    DelimAt,

    /// The `.` or `+` `<delim-token>` type.
    DelimDotOrPlus,

    /// The `-` `<delim-token>` type.
    DelimMinus,

    /// The `?` `<delim-token>` type.
    DelimQuestion,

    /// The `$`, `^`, or `~` `<delim-token>` type.
    DelimAssorted,

    /// The `=` `<delim-token>` type.
    DelimEquals,

    /// The `|` `<delim-token>` type.
    DelimBar,

    /// The `/` `<delim-token>` type.
    DelimSlash,

    /// The `*` `<delim-token>` type.
    DelimAsterisk,

    /// The `%` `<delim-token>` type.
    DelimPercent,

    /// A type indicating any other token.
    Other,
}

#[cfg(feature = "malloc_size_of")]
malloc_size_of::malloc_size_of_is_0!(TokenSerializationType);

impl TokenSerializationType {
    /// Return a value that represents the absence of a token, e.g. before the start of the input.
    #[deprecated(
        since = "0.32.1",
        note = "use TokenSerializationType::Nothing or TokenSerializationType::default() instead"
    )]
    pub fn nothing() -> TokenSerializationType {
        Default::default()
    }

    /// If this value is `TokenSerializationType::Nothing`, set it to the given value instead.
    pub fn set_if_nothing(&mut self, new_value: TokenSerializationType) {
        if matches!(self, TokenSerializationType::Nothing) {
            *self = new_value
        }
    }

    /// Return true if, when a token of category `self` is serialized just before
    /// a token of category `other` with no whitespace in between,
    /// an empty comment `/**/` needs to be inserted between them
    /// so that they are not re-parsed as a single token.
    ///
    /// See https://drafts.csswg.org/css-syntax/#serialization
    ///
    /// See https://github.com/w3c/csswg-drafts/issues/4088 for the
    /// `DelimPercent` bits.
    pub fn needs_separator_when_before(self, other: TokenSerializationType) -> bool {
        use self::TokenSerializationType::*;
        match self {
            Ident => matches!(
                other,
                Ident
                    | Function
                    | UrlOrBadUrl
                    | DelimMinus
                    | Number
                    | Percentage
                    | Dimension
                    | CDC
                    | OpenParen
            ),
            AtKeywordOrHash | Dimension => matches!(
                other,
                Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension | CDC
            ),
            DelimHash | DelimMinus => matches!(
                other,
                Ident | Function | UrlOrBadUrl | DelimMinus | Number | Percentage | Dimension
            ),
            Number => matches!(
                other,
                Ident
                    | Function
                    | UrlOrBadUrl
                    | DelimMinus
                    | Number
                    | Percentage
                    | DelimPercent
                    | Dimension
            ),
            DelimAt => matches!(other, Ident | Function | UrlOrBadUrl | DelimMinus),
            DelimDotOrPlus => matches!(other, Number | Percentage | Dimension),
            DelimAssorted | DelimAsterisk => matches!(other, DelimEquals),
            DelimBar => matches!(other, DelimEquals | DelimBar | DashMatch),
            DelimSlash => matches!(other, DelimAsterisk | SubstringMatch),
            Nothing | WhiteSpace | Percentage | UrlOrBadUrl | Function | CDC | OpenParen
            | DashMatch | SubstringMatch | DelimQuestion | DelimEquals | DelimPercent | Other => {
                false
            }
        }
    }
}

impl Token<'_> {
    /// Categorize a token into a type that determines when `/**/` needs to be inserted
    /// between two tokens when serialized next to each other without whitespace in between.
    ///
    /// See the `TokenSerializationType::needs_separator_when_before` method.
    pub fn serialization_type(&self) -> TokenSerializationType {
        use self::TokenSerializationType::*;
        match self {
            Token::Ident(_) => Ident,
            Token::AtKeyword(_) | Token::Hash(_) | Token::IDHash(_) => AtKeywordOrHash,
            Token::UnquotedUrl(_) | Token::BadUrl(_) => UrlOrBadUrl,
            Token::Delim('#') => DelimHash,
            Token::Delim('@') => DelimAt,
            Token::Delim('.') | Token::Delim('+') => DelimDotOrPlus,
            Token::Delim('-') => DelimMinus,
            Token::Delim('?') => DelimQuestion,
            Token::Delim('$') | Token::Delim('^') | Token::Delim('~') => DelimAssorted,
            Token::Delim('%') => DelimPercent,
            Token::Delim('=') => DelimEquals,
            Token::Delim('|') => DelimBar,
            Token::Delim('/') => DelimSlash,
            Token::Delim('*') => DelimAsterisk,
            Token::Number { .. } => Number,
            Token::Percentage { .. } => Percentage,
            Token::Dimension { .. } => Dimension,
            Token::WhiteSpace(_) => WhiteSpace,
            Token::Comment(_) => DelimSlash,
            Token::DashMatch => DashMatch,
            Token::SubstringMatch => SubstringMatch,
            Token::CDC => CDC,
            Token::Function(_) => Function,
            Token::ParenthesisBlock => OpenParen,
            Token::SquareBracketBlock
            | Token::CurlyBracketBlock
            | Token::CloseParenthesis
            | Token::CloseSquareBracket
            | Token::CloseCurlyBracket
            | Token::QuotedString(_)
            | Token::BadString(_)
            | Token::Delim(_)
            | Token::Colon
            | Token::Semicolon
            | Token::Comma
            | Token::CDO
            | Token::IncludeMatch
            | Token::PrefixMatch
            | Token::SuffixMatch => Other,
        }
    }
}

Coverage Report

Created: 2026-08-14 07:12

Line	Count	Source
1		/* This Source Code Form is subject to the terms of the Mozilla Public
2		* License, v. 2.0. If a copy of the MPL was not distributed with this
3		* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
5		use std::fmt::{self, Write};
6		use std::str;
7
8		#[cfg(feature = "fast_match_byte")]
9		pub use crate::match_byte;
10
11		use super::Token;
12
13		/// Trait for things the can serialize themselves in CSS syntax.
14		pub trait ToCss {
15		/// Serialize `self` in CSS syntax, writing to `dest`.
16		fn to_css<W>(&self, dest: &mut W) -> fmt::Result
17		where
18		W: fmt::Write;
19
20		/// Serialize `self` in CSS syntax and return a string.
21		///
22		/// (This is a convenience wrapper for `to_css` and probably should not be overridden.)
23		#[inline]
24		fn to_css_string(&self) -> String {
25		let mut s = String::new();
26		self.to_css(&mut s).unwrap();
27		s
28		}
29		}
30
31		#[inline]
32	60.8M	fn write_numeric<W>(value: f32, int_value: Option<i32>, has_sign: bool, dest: &mut W) -> fmt::Result
33	60.8M	where
34	60.8M	W: fmt::Write,
35		{
36	60.8M	if value == 0.0 && value.is_sign_negative() {
37		// Negative zero. Work around #20596.
38	19.8k	return dest.write_str("-0");
39	60.8M	}
40		// NOTE: `value.value >= 0` is true for negative 0 but we've dealt with it above.
41	60.8M	if has_sign && value >= 0.0 {
42	7.95M	dest.write_str("+")?;
43	52.9M	}
44
45	60.8M	if let Some(v) = int_value {
46	4.52M	return write!(dest, "{}", v);
47	56.3M	}
48
49	56.3M	let notation = dtoa_short::write(dest, value)?;
50	56.3M	if value.fract() == 0. && !notation.decimal_point && !notation.scientific {
51	56.0M	dest.write_str(".0")?;
52	307k	}
53	56.3M	Ok(())
54	60.8M	}
55
56		impl ToCss for Token<'_> {
57	76.6M	fn to_css<W>(&self, dest: &mut W) -> fmt::Result
58	76.6M	where
59	76.6M	W: fmt::Write,
60		{
61	76.6M	match *self {
62	603k	Token::Ident(ref value) => serialize_identifier(value, dest)?,
63	433k	Token::AtKeyword(ref value) => {
64	433k	dest.write_str("@")?;
65	433k	serialize_identifier(value, dest)?;
66		}
67	36.2k	Token::Hash(ref value) => {
68	36.2k	dest.write_str("#")?;
69	36.2k	serialize_name(value, dest)?;
70		}
71	76.9k	Token::IDHash(ref value) => {
72	76.9k	dest.write_str("#")?;
73	76.9k	serialize_identifier(value, dest)?;
74		}
75	408k	Token::QuotedString(ref value) => serialize_string(value, dest)?,
76	40.3k	Token::UnquotedUrl(ref value) => {
77	40.3k	dest.write_str("url(")?;
78	40.3k	serialize_unquoted_url(value, dest)?;
79	40.3k	dest.write_str(")")?;
80		}
81	11.8M	Token::Delim(value) => dest.write_char(value)?,
82
83		Token::Number {
84	60.6M	value,
85	60.6M	int_value,
86	60.6M	has_sign,
87	60.6M	} => write_numeric(value, int_value, has_sign, dest)?,
88		Token::Percentage {
89	61.3k	unit_value,
90	61.3k	int_value,
91	61.3k	has_sign,
92		} => {
93	61.3k	write_numeric(unit_value * 100., int_value, has_sign, dest)?;
94	61.3k	dest.write_str("%")?;
95		}
96		Token::Dimension {
97	156k	value,
98	156k	int_value,
99	156k	has_sign,
100	156k	ref unit,
101		} => {
102	156k	write_numeric(value, int_value, has_sign, dest)?;
103		// Disambiguate with scientific notation.
104	156k	let unit = &**unit;
105		// TODO(emilio): This doesn't handle e.g. 100E1m, which gets us
106		// an unit of "E1m"...
107	156k	if unit == "e" \|\| unit == "E" \|\| unit.starts_with("e-") \|\| unit.starts_with("E-") {
108	88.4k	dest.write_str("\\65 ")?;
109	88.4k	serialize_name(&unit[1..], dest)?;
110		} else {
111	67.6k	serialize_identifier(unit, dest)?;
112		}
113		}
114
115	252k	Token::WhiteSpace(content) => dest.write_str(content)?,
116	0	Token::Comment(content) => {
117	0	dest.write_str("/*")?;
118	0	dest.write_str(content)?;
119	0	dest.write_str("*/")?
120		}
121	148k	Token::Colon => dest.write_str(":")?,
122	229k	Token::Semicolon => dest.write_str(";")?,
123	207k	Token::Comma => dest.write_str(",")?,
124	95.7k	Token::IncludeMatch => dest.write_str("~=")?,
125	53.3k	Token::DashMatch => dest.write_str("\|=")?,
126	157k	Token::PrefixMatch => dest.write_str("^=")?,
127	48.4k	Token::SuffixMatch => dest.write_str("$=")?,
128	132k	Token::SubstringMatch => dest.write_str("*=")?,
129	34.7k	Token::CDO => dest.write_str("<!--")?,
130	137k	Token::CDC => dest.write_str("-->")?,
131
132	7.54k	Token::Function(ref name) => {
133	7.54k	serialize_identifier(name, dest)?;
134	7.54k	dest.write_str("(")?;
135		}
136	9.31k	Token::ParenthesisBlock => dest.write_str("(")?,
137	5.89k	Token::SquareBracketBlock => dest.write_str("[")?,
138	399k	Token::CurlyBracketBlock => dest.write_str("{")?,
139
140	0	Token::BadUrl(ref contents) => {
141	0	dest.write_str("url(")?;
142	0	dest.write_str(contents)?;
143	0	dest.write_char(')')?;
144		}
145	0	Token::BadString(ref value) => {
146		// During tokenization, an unescaped newline after a quote causes
147		// the token to be a BadString instead of a QuotedString.
148		// The BadString token ends just before the newline
149		// (which is in a separate WhiteSpace token),
150		// and therefore does not have a closing quote.
151	0	dest.write_char('"')?;
152	0	CssStringWriter::new(dest).write_str(value)?;
153		}
154	15.3k	Token::CloseParenthesis => dest.write_str(")")?,
155	5.37k	Token::CloseSquareBracket => dest.write_str("]")?,
156	398k	Token::CloseCurlyBracket => dest.write_str("}")?,
157		}
158	76.6M	Ok(())
159	76.6M	}
160		}
161
162	479k	fn hex_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result
163	479k	where
164	479k	W: fmt::Write,
165		{
166		static HEX_DIGITS: &[u8; 16] = b"0123456789abcdef";
167		let b3;
168		let b4;
169	479k	let bytes = if ascii_byte > 0x0F {
170	307k	let high = (ascii_byte >> 4) as usize;
171	307k	let low = (ascii_byte & 0x0F) as usize;
172	307k	b4 = [b'\\', HEX_DIGITS[high], HEX_DIGITS[low], b' '];
173	307k	&b4[..]
174		} else {
175	171k	b3 = [b'\\', HEX_DIGITS[ascii_byte as usize], b' '];
176	171k	&b3[..]
177		};
178	479k	dest.write_str(unsafe { str::from_utf8_unchecked(bytes) })
179	479k	}
180
181	617k	fn char_escape<W>(ascii_byte: u8, dest: &mut W) -> fmt::Result
182	617k	where
183	617k	W: fmt::Write,
184		{
185	617k	let bytes = [b'\\', ascii_byte];
186	617k	dest.write_str(unsafe { str::from_utf8_unchecked(&bytes) })
187	617k	}
188
189		/// Write a CSS identifier, escaping characters as necessary.
190	1.18M	pub fn serialize_identifier<W>(mut value: &str, dest: &mut W) -> fmt::Result
191	1.18M	where
192	1.18M	W: fmt::Write,
193		{
194	1.18M	if value.is_empty() {
195	0	return Ok(());
196	1.18M	}
197
198	1.18M	if let Some(value) = value.strip_prefix("--") {
199	31.2k	dest.write_str("--")?;
200	31.2k	serialize_name(value, dest)
201	1.15M	} else if value == "-" {
202	4.92k	dest.write_str("\\-")
203		} else {
204	1.15M	if value.as_bytes()[0] == b'-' {
205	108k	dest.write_str("-")?;
206	108k	value = &value[1..];
207	1.04M	}
208	1.15M	if let digit @ b'0'..=b'9' = value.as_bytes()[0] {
209	1.09k	hex_escape(digit, dest)?;
210	1.09k	value = &value[1..];
211	1.15M	}
212	1.15M	serialize_name(value, dest)
213		}
214	1.18M	}
215
216		/// Write a CSS name, like a custom property name.
217		///
218		/// You should only use this when you know what you're doing, when in doubt,
219		/// consider using `serialize_identifier`.
220	1.30M	pub fn serialize_name<W>(value: &str, dest: &mut W) -> fmt::Result
221	1.30M	where
222	1.30M	W: fmt::Write,
223		{
224	1.30M	let mut chunk_start = 0;
225	222M	for (i, b) in value.bytes().enumerate() {
226	222M	let escaped = match_byte! { b,
227	15.3M	b'0'..=b'9' \| b'A'..=b'Z' \| b'a'..=b'z' \| b'_' \| b'-' => continue,
228	0	b'\0' => Some("\u{FFFD}"),
229	222M	b => {
230	207M	if !b.is_ascii() {
231	206M	continue;
232	598k	}
233	598k	None
234		},
235		};
236	598k	dest.write_str(&value[chunk_start..i])?;
237	598k	if let Some(escaped) = escaped {
238	0	dest.write_str(escaped)?;
239	598k	} else if (b'\x01'..=b'\x1F').contains(&b) \|\| b == b'\x7F' {
240	237k	hex_escape(b, dest)?;
241		} else {
242	360k	char_escape(b, dest)?;
243		}
244	598k	chunk_start = i + 1;
245		}
246	1.30M	dest.write_str(&value[chunk_start..])
247	1.30M	}
248
249	40.3k	fn serialize_unquoted_url<W>(value: &str, dest: &mut W) -> fmt::Result
250	40.3k	where
251	40.3k	W: fmt::Write,
252		{
253	40.3k	let mut chunk_start = 0;
254	180M	for (i, b) in value.bytes().enumerate() {
255	180M	let hex = match_byte! { b,
256	34.6k	b'\0'..=b' ' \| b'\x7F' => true,
257	256k	b'(' \| b')' \| b'"' \| b'\'' \| b'\\' => false,
258	180M	_ => continue,
259		};
260	291k	dest.write_str(&value[chunk_start..i])?;
261	291k	if hex {
262	34.6k	hex_escape(b, dest)?;
263		} else {
264	256k	char_escape(b, dest)?;
265		}
266	291k	chunk_start = i + 1;
267		}
268	40.3k	dest.write_str(&value[chunk_start..])
269	40.3k	}
270
271		/// Write a double-quoted CSS string token, escaping content as necessary.
272	408k	pub fn serialize_string<W>(value: &str, dest: &mut W) -> fmt::Result
273	408k	where
274	408k	W: fmt::Write,
275		{
276	408k	dest.write_str("\"")?;
277	408k	CssStringWriter::new(dest).write_str(value)?;
278	408k	dest.write_str("\"")?;
279	408k	Ok(())
280	408k	}
281
282		/// A `fmt::Write` adapter that escapes text for writing as a double-quoted CSS string.
283		/// Quotes are not included.
284		///
285		/// Typical usage:
286		///
287		/// ```rust,ignore
288		/// fn write_foo<W>(foo: &Foo, dest: &mut W) -> fmt::Result where W: fmt::Write {
289		/// dest.write_str("\"")?;
290		/// {
291		/// let mut string_dest = CssStringWriter::new(dest);
292		/// // Write into string_dest...
293		/// }
294		/// dest.write_str("\"")?;
295		/// Ok(())
296		/// }
297		/// ```
298		pub struct CssStringWriter<'a, W> {
299		inner: &'a mut W,
300		}
301
302		impl<'a, W> CssStringWriter<'a, W>
303		where
304		W: fmt::Write,
305		{
306		/// Wrap a text writer to create a `CssStringWriter`.
307	408k	pub fn new(inner: &'a mut W) -> CssStringWriter<'a, W> {
308	408k	CssStringWriter { inner }
309	408k	}
310		}
311
312		impl<W> fmt::Write for CssStringWriter<'_, W>
313		where
314		W: fmt::Write,
315		{
316	408k	fn write_str(&mut self, s: &str) -> fmt::Result {
317	408k	let mut chunk_start = 0;
318	73.7M	for (i, b) in s.bytes().enumerate() {
319	73.7M	let escaped = match_byte! { b,
320	152k	b'"' => Some("\\\""),
321	913	b'\\' => Some("\\\\"),
322	0	b'\0' => Some("\u{FFFD}"),
323	205k	b'\x01'..=b'\x1F' \| b'\x7F' => None,
324	73.3M	_ => continue,
325		};
326	359k	self.inner.write_str(&s[chunk_start..i])?;
327	359k	match escaped {
328	153k	Some(x) => self.inner.write_str(x)?,
329	205k	None => hex_escape(b, self.inner)?,
330		};
331	359k	chunk_start = i + 1;
332		}
333	408k	self.inner.write_str(&s[chunk_start..])
334	408k	}
335		}
336
337		macro_rules! impl_tocss_for_int {
338		($T: ty) => {
339		impl ToCss for $T {
340		fn to_css<W>(&self, dest: &mut W) -> fmt::Result
341		where
342		W: fmt::Write,
343		{
344		let mut buf = itoa::Buffer::new();
345		dest.write_str(buf.format(*self))
346		}
347		}
348		};
349		}
350
351		impl_tocss_for_int!(i8);
352		impl_tocss_for_int!(u8);
353		impl_tocss_for_int!(i16);
354		impl_tocss_for_int!(u16);
355		impl_tocss_for_int!(i32);
356		impl_tocss_for_int!(u32);
357		impl_tocss_for_int!(i64);
358		impl_tocss_for_int!(u64);
359
360		macro_rules! impl_tocss_for_float {
361		($T: ty) => {
362		impl ToCss for $T {
363		fn to_css<W>(&self, dest: &mut W) -> fmt::Result
364		where
365		W: fmt::Write,
366		{
367		dtoa_short::write(dest, *self).map(\|_\| ())
368		}
369		}
370		};
371		}
372
373		impl_tocss_for_float!(f32);
374		impl_tocss_for_float!(f64);
375
376		/// A category of token. See the `needs_separator_when_before` method.
377		#[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
378		pub enum TokenSerializationType {
379		/// No token serialization type.
380		#[default]
381		Nothing,
382
383		/// The [`<whitespace-token>`](https://drafts.csswg.org/css-syntax/#whitespace-token-diagram)
384		/// type.
385		WhiteSpace,
386
387		/// The [`<at-keyword-token>`](https://drafts.csswg.org/css-syntax/#at-keyword-token-diagram)
388		/// type, the "[`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with
389		/// the type flag set to 'unrestricted'" type, or the
390		/// "[`<hash-token>`](https://drafts.csswg.org/css-syntax/#hash-token-diagram) with the type
391		/// flag set to 'id'" type.
392		AtKeywordOrHash,
393
394		/// The [`<number-token>`](https://drafts.csswg.org/css-syntax/#number-token-diagram) type.
395		Number,
396
397		/// The [`<dimension-token>`](https://drafts.csswg.org/css-syntax/#dimension-token-diagram)
398		/// type.
399		Dimension,
400
401		/// The [`<percentage-token>`](https://drafts.csswg.org/css-syntax/#percentage-token-diagram)
402		/// type.
403		Percentage,
404
405		/// The [`<url-token>`](https://drafts.csswg.org/css-syntax/#url-token-diagram) or
406		/// `<bad-url-token>` type.
407		UrlOrBadUrl,
408
409		/// The [`<function-token>`](https://drafts.csswg.org/css-syntax/#function-token-diagram) type.
410		Function,
411
412		/// The [`<ident-token>`](https://drafts.csswg.org/css-syntax/#ident-token-diagram) type.
413		Ident,
414
415		/// The `-->` [`<CDC-token>`](https://drafts.csswg.org/css-syntax/#CDC-token-diagram) type.
416		CDC,
417
418		/// The `\|=`
419		/// [`<dash-match-token>`](https://drafts.csswg.org/css-syntax/#dash-match-token-diagram) type.
420		DashMatch,
421
422		/// The `*=`
423		/// [`<substring-match-token>`](https://drafts.csswg.org/css-syntax/#substring-match-token-diagram)
424		/// type.
425		SubstringMatch,
426
427		/// The `<(-token>` type.
428		OpenParen,
429
430		/// The `#` `<delim-token>` type.
431		DelimHash,
432
433		/// The `@` `<delim-token>` type.
434		DelimAt,
435
436		/// The `.` or `+` `<delim-token>` type.
437		DelimDotOrPlus,
438
439		/// The `-` `<delim-token>` type.
440		DelimMinus,
441
442		/// The `?` `<delim-token>` type.
443		DelimQuestion,
444
445		/// The `$`, `^`, or `~` `<delim-token>` type.
446		DelimAssorted,
447
448		/// The `=` `<delim-token>` type.
449		DelimEquals,
450
451		/// The `\|` `<delim-token>` type.
452		DelimBar,
453
454		/// The `/` `<delim-token>` type.
455		DelimSlash,
456
457		/// The `*` `<delim-token>` type.
458		DelimAsterisk,
459
460		/// The `%` `<delim-token>` type.
461		DelimPercent,
462
463		/// A type indicating any other token.
464		Other,
465		}
466
467		#[cfg(feature = "malloc_size_of")]
468		malloc_size_of::malloc_size_of_is_0!(TokenSerializationType);
469
470		impl TokenSerializationType {
471		/// Return a value that represents the absence of a token, e.g. before the start of the input.
472		#[deprecated(
473		since = "0.32.1",
474		note = "use TokenSerializationType::Nothing or TokenSerializationType::default() instead"
475		)]
476	15.3k	pub fn nothing() -> TokenSerializationType {
477	15.3k	Default::default()
478	15.3k	}
479
480		/// If this value is `TokenSerializationType::Nothing`, set it to the given value instead.
481	0	pub fn set_if_nothing(&mut self, new_value: TokenSerializationType) {
482	0	if matches!(self, TokenSerializationType::Nothing) {
483	0	*self = new_value
484	0	}
485	0	}
486
487		/// Return true if, when a token of category `self` is serialized just before
488		/// a token of category `other` with no whitespace in between,
489		/// an empty comment `/**/` needs to be inserted between them
490		/// so that they are not re-parsed as a single token.
491		///
492		/// See https://drafts.csswg.org/css-syntax/#serialization
493		///
494		/// See https://github.com/w3c/csswg-drafts/issues/4088 for the
495		/// `DelimPercent` bits.
496	76.2M	pub fn needs_separator_when_before(self, other: TokenSerializationType) -> bool {
497		use self::TokenSerializationType::*;
498	76.2M	match self {
499	592k	Ident => matches!(
500	600k	other,
501		Ident
502		\| Function
503		\| UrlOrBadUrl
504		\| DelimMinus
505		\| Number
506		\| Percentage
507		\| Dimension
508		\| CDC
509		\| OpenParen
510		),
511	617k	AtKeywordOrHash \| Dimension => matches!(
512	700k	other,
513		Ident \| Function \| UrlOrBadUrl \| DelimMinus \| Number \| Percentage \| Dimension \| CDC
514		),
515	300k	DelimHash \| DelimMinus => matches!(
516	4.11M	other,
517		Ident \| Function \| UrlOrBadUrl \| DelimMinus \| Number \| Percentage \| Dimension
518		),
519	322k	Number => matches!(
520	60.6M	other,
521		Ident
522		\| Function
523		\| UrlOrBadUrl
524		\| DelimMinus
525		\| Number
526		\| Percentage
527		\| DelimPercent
528		\| Dimension
529		),
530	137k	DelimAt => matches!(other, Ident \| Function \| UrlOrBadUrl \| DelimMinus),
531	21.7k	DelimDotOrPlus => matches!(other, Number \| Percentage \| Dimension),
532	345k	DelimAssorted \| DelimAsterisk => matches!(other, DelimEquals),
533	6.49M	DelimBar => matches!(other, DelimEquals \| DelimBar \| DashMatch),
534	45.7k	DelimSlash => matches!(other, DelimAsterisk \| SubstringMatch),
535		Nothing \| WhiteSpace \| Percentage \| UrlOrBadUrl \| Function \| CDC \| OpenParen
536		\| DashMatch \| SubstringMatch \| DelimQuestion \| DelimEquals \| DelimPercent \| Other => {
537	3.08M	false
538		}
539		}
540	76.2M	}
541		}
542
543		impl Token<'_> {
544		/// Categorize a token into a type that determines when `/**/` needs to be inserted
545		/// between two tokens when serialized next to each other without whitespace in between.
546		///
547		/// See the `TokenSerializationType::needs_separator_when_before` method.
548	76.2M	pub fn serialization_type(&self) -> TokenSerializationType {
549		use self::TokenSerializationType::*;
550	76.2M	match self {
551	603k	Token::Ident(_) => Ident,
552	546k	Token::AtKeyword(_) \| Token::Hash(_) \| Token::IDHash(_) => AtKeywordOrHash,
553	40.3k	Token::UnquotedUrl(_) \| Token::BadUrl(_) => UrlOrBadUrl,
554	3.21k	Token::Delim('#') => DelimHash,
555	137k	Token::Delim('@') => DelimAt,
556	22.0k	Token::Delim('.') \| Token::Delim('+') => DelimDotOrPlus,
557	4.11M	Token::Delim('-') => DelimMinus,
558	3.33k	Token::Delim('?') => DelimQuestion,
559	211k	Token::Delim('$') \| Token::Delim('^') \| Token::Delim('~') => DelimAssorted,
560	31.6k	Token::Delim('%') => DelimPercent,
561	45.0k	Token::Delim('=') => DelimEquals,
562	6.49M	Token::Delim('\|') => DelimBar,
563	45.8k	Token::Delim('/') => DelimSlash,
564	134k	Token::Delim('*') => DelimAsterisk,
565	60.6M	Token::Number { .. } => Number,
566	61.3k	Token::Percentage { .. } => Percentage,
567	156k	Token::Dimension { .. } => Dimension,
568	252k	Token::WhiteSpace(_) => WhiteSpace,
569	0	Token::Comment(_) => DelimSlash,
570	53.3k	Token::DashMatch => DashMatch,
571	132k	Token::SubstringMatch => SubstringMatch,
572	137k	Token::CDC => CDC,
573	7.54k	Token::Function(_) => Function,
574	9.31k	Token::ParenthesisBlock => OpenParen,
575		Token::SquareBracketBlock
576		\| Token::CurlyBracketBlock
577		\| Token::CloseParenthesis
578		\| Token::CloseSquareBracket
579		\| Token::CloseCurlyBracket
580		\| Token::QuotedString(_)
581		\| Token::BadString(_)
582		\| Token::Delim(_)
583		\| Token::Colon
584		\| Token::Semicolon
585		\| Token::Comma
586		\| Token::CDO
587		\| Token::IncludeMatch
588		\| Token::PrefixMatch
589	2.30M	\| Token::SuffixMatch => Other,
590		}
591	76.2M	}
592		}