### Rust: Basic Parser Setup and Token Iteration

Source: https://context7.com/servo/rust-cssparser/llms.txt

Demonstrates how to set up a CSS parser in Rust using rust-cssparser and iterate through its tokens. It shows basic token matching and how to include or exclude whitespace and comments during iteration.

```rust
use cssparser::{Parser, ParserInput, Token};

// Create parser input from CSS string
let css = "color: red; background: blue;";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);

// Iterate through tokens (skips whitespace and comments)
loop {
    match parser.next() {
        Ok(token) => {
            match token {
                Token::Ident(name) => println!("Identifier: {}", name),
                Token::Colon => println!("Colon"),
                Token::Semicolon => println!("Semicolon"),
                Token::Delim(c) => println!("Delimiter: {}", c),
                _ => println!("Token: {:?}", token),
            }
        }
        Err(_) => {
            // End of input or parse error
            break;
        }
    }
}

// Include whitespace in iteration
let mut input2 = ParserInput::new("foo   bar");
let mut parser2 = Parser::new(&mut input2);
while let Ok(token) = parser2.next_including_whitespace() {
    println!("{:?}", token);
}
// Output: Ident("foo"), WhiteSpace("   "), Ident("bar")

// Include both whitespace and comments
let mut input3 = ParserInput::new("foo /* comment */ bar");
let mut parser3 = Parser::new(&mut input3);
while let Ok(token) = parser3.next_including_whitespace_and_comments() {
    println!("{:?}", token);
}
// Output: Ident("foo"), WhiteSpace(" "), Comment(" comment "), WhiteSpace(" "), Ident("bar")

```

--------------------------------

### Rust: Parsing Comma-Separated Lists

Source: https://context7.com/servo/rust-cssparser/llms.txt

Illustrates parsing comma-separated lists of values in CSS using the `parse_comma_separated` method from the `cssparser` crate. Examples include parsing font family names (identifiers or strings) and numerical lengths with units. Dependencies include the `cssparser` crate.

```rust
use cssparser::{Parser, ParserInput, ParseError};

fn parse_font_family(input: &mut Parser) -> Result<Vec<String>, ParseError<()>> {
    input.parse_comma_separated(|input| {
        // Each font family can be a quoted string or an identifier
        let family = input.expect_ident_or_string()?;
        Ok(family.to_string())
    })
}

// Example usage
let css = "Arial, 'Times New Roman', sans-serif";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);

match parse_font_family(&mut parser) {
    Ok(families) => {
        println!("Font families:");
        for family in families {
            println!("  - {}", family);
        }
    }
    Err(e) => println!("Parse error: {:?}", e),
}
// Output:
// Font families:
//   - Arial
//   - Times New Roman
//   - sans-serif

// Parsing multiple values with custom parser
fn parse_lengths(input: &mut Parser) -> Result<Vec<f32>, ParseError<()>> {
    input.parse_comma_separated(|input| {
        let token = input.next()?;
        match token {
            cssparser::Token::Dimension { value, unit, .. } if unit == "px" => Ok(*value),
            cssparser::Token::Number { value, .. } => Ok(*value),
            _ => Err(input.new_custom_error(())),
        }
    })
}

let css = "10px, 20, 30px";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);
let lengths = parse_lengths(&mut parser).unwrap();
println!("Lengths: {:?}", lengths); // Lengths: [10.0, 20.0, 30.0]

```

--------------------------------

### CSS urange Syntax Testing

Source: https://github.com/servo/rust-cssparser/blob/main/src/css-parsing-tests/README.rst

Tests the urange syntax defined in CSS Syntax Level 3. The input is a JSON string representing Unicode, and the output is either null for invalid syntax or an array of two integers [start, end].

```json
{
    "tests": [
        {
            "input": "U+2000-U+200A",
            "output": [8192, 8192+10]
        },
        {
            "input": "U+0020",
            "output": [32, 32]
        },
        {
            "input": "invalid",
            "output": null
        }
    ]
}
```

--------------------------------

### Serialize CSS Tokens and Identifiers in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

Demonstrates serializing various CSS tokens, identifiers, and strings back into their CSS string representation using the cssparser library's `ToCss` trait. It covers basic tokens like `color` and `:`, escaped identifiers with special characters or spaces, and properly quoted strings. The example also shows how to implement `ToCss` for custom structs, like a `Color` struct, to serialize them into CSS values (e.g., `rgb(...)`).

```rust
use cssparser::{Parser, ParserInput, Token, ToCss, serialize_identifier, serialize_string};
use std::fmt::Write;

// Serialize individual tokens
fn serialize_tokens(css: &str) {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);

    while let Ok(token) = parser.next_including_whitespace() {
        let serialized = token.to_css_string();
        println!("Token: {:?} => {}", token, serialized);
    }
}

serialize_tokens("color: red");
// Output:
// Token: Ident("color") => color
// Token: Colon => :
// Token: WhiteSpace(" ") => 
// Token: Ident("red") => red

// Serialize identifiers with proper escaping
let identifiers = vec!["simple", "with-dash", "123start", "with space"];
for ident in identifiers {
    let mut output = String::new();
    serialize_identifier(ident, &mut output).unwrap();
    println!("{} => {}", ident, output);
}
// Output:
// simple => simple
// with-dash => with-dash
// 123start => \31 23start
// with space => with\ space

// Serialize strings with proper escaping
let strings = vec!["hello", "with\"quotes\"", "line\nbreak"];
for s in strings {
    let mut output = String::new();
    serialize_string(s, &mut output).unwrap();
    println!("{:?}" => {}", s, output);
}
// Output:
// "hello" => "hello"
// "with\"quotes\"" => "with\"quotes\""
// "line\nbreak" => "line\nbreak"

// Custom struct implementing ToCss
#[derive(Debug)]
struct Color {
    r: u8,
    g: u8,
    b: u8,
}

impl ToCss for Color {
    fn to_css<W>(&self, dest: &mut W) -> std::fmt::Result
    where W: Write
    {
        write!(dest, "rgb({}, {}, {})", self.r, self.g, self.b)
    }
}

let color = Color { r: 255, g: 128, b: 0 };
println!("Color CSS: {}", color.to_css_string());
// Output: Color CSS: rgb(255, 128, 0)

```

--------------------------------

### Implement Custom CSS Parse Error Handling in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

Illustrates how to define and use custom error types with `cssparser` in Rust. This example shows a function that parses a color, returning a `CustomError` enum if the color is not one of the allowed values, and demonstrates how to handle these custom errors during parsing.

```rust
// Custom error type
#[derive(Debug)]
enum CustomError {
    InvalidColor,
    InvalidUnit,
}

fn parse_color_with_custom_error(input: &mut Parser) -> Result<String, ParseError<CustomError>> {
    let color = input.expect_ident()?;

    // Validate color
    if !["red", "green", "blue", "black", "white"].contains(&color.as_ref()) {
        return Err(input.new_custom_error(CustomError::InvalidColor));
    }

    Ok(color.to_string())
}

let css = "purple";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);
match parse_color_with_custom_error(&mut parser) {
    Ok(color) => println!("Valid color: {}", color),
    Err(e) => println!("Error: {:?} at line {}, col {}", e.kind, e.location.line, e.location.column),
}
// Output: Error: Custom(InvalidColor) at line 1, col 1

```

--------------------------------

### Parse CSS Unicode Ranges in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

Parses Unicode range values, commonly used in CSS @font-face descriptors, using the cssparser library. It demonstrates how to parse single ranges like 'U+0025-00FF' and multiple comma-separated ranges. The function returns a vector of UnicodeRange structs, each containing start and end code points. It also shows how to extract these ranges from a CSS string.

```rust
use cssparser::{Parser, ParserInput, UnicodeRange};

fn parse_unicode_ranges(css: &str) -> Result<Vec<UnicodeRange>, Box<dyn std::error::Error>> {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);

    let ranges = parser.parse_comma_separated(|parser| {
        UnicodeRange::parse(parser).map_err(|e| e.into())
    })?;

    Ok(ranges)
}

// Parse single range
let css = "U+0025-00FF";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);
let range = UnicodeRange::parse(&mut parser).unwrap();
println!("Range: U+{:04X}-U+{:04X}", range.start, range.end);
// Output: Range: U+0025-U+00FF

// Parse multiple ranges
let css = "U+0025-00FF, U+4E00-9FFF, U+30??";
match parse_unicode_ranges(css) {
    Ok(ranges) => {
        for range in ranges {
            println!("U+{:04X}-U+{:04X} ({} characters)",
                     range.start, range.end, range.end - range.start + 1);
        }
    }
    Err(e) => println!("Error: {}", e),
}
// Output:
// U+0025-U+00FF (219 characters)
// U+4E00-U+9FFF (20992 characters)
// U+3000-U+30FF (256 characters)

// Using in @font-face context
let css = r#"@font-face {
    font-family: 'MyFont';
    unicode-range: U+0025-00FF, U+4E00-9FFF;
}
"#;

```

--------------------------------

### Rust: Try-Parse with Rollback for Alternatives

Source: https://context7.com/servo/rust-cssparser/llms.txt

Demonstrates the try-parse pattern for backtracking when parsing alternative CSS values like 'none', 'url()', or color names. It uses a closure to attempt parsing and rolls back if it fails, allowing subsequent alternatives to be tried. Dependencies include the `cssparser` crate.

```rust
use cssparser::{Parser, ParserInput, ParseError};

#[derive(Debug)]
enum BackgroundValue {
    None,
    Color(String),
    Url(String),
}

fn parse_background(input: &mut Parser) -> Result<BackgroundValue, ParseError<()>> {
    // Try parsing "none" keyword
    if input.try_parse(|input| input.expect_ident_matching("none")).is_ok() {
        return Ok(BackgroundValue::None);
    }

    // Try parsing a URL
    if let Ok(url) = input.try_parse(|input| input.expect_url()) {
        return Ok(BackgroundValue::Url(url.to_string()));
    }

    // Try parsing a color name
    if let Ok(color) = input.try_parse(|input| input.expect_ident()) {
        return Ok(BackgroundValue::Color(color.to_string()));
    }

    // Nothing matched
    Err(input.new_custom_error(()))
}

// Examples
let test_cases = vec![
    "none",
    "url(image.png)",
    "red",
];

for css in test_cases {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);
    match parse_background(&mut parser) {
        Ok(bg) => println!("{:?}", bg),
        Err(_) => println!("Failed to parse: {}", css),
    }
}
// Output:
// None
// Url("image.png")
// Color("red")

```

--------------------------------

### Rust: Parsing Nested Blocks and Functions

Source: https://context7.com/servo/rust-cssparser/llms.txt

Demonstrates parsing nested blocks (like `rgb(...)` or `{ ... }`) and function calls using the `cssparser` crate. It shows how to expect specific function names and parse content within nested structures, including handling expected tokens like integers and commas. Dependencies include the `cssparser` crate.

```rust
use cssparser::{Parser, ParserInput, Token, ParseError};

fn parse_rgb_function(input: &mut Parser) -> Result<(u8, u8, u8), ParseError<()>> {
    // Expect function token with name "rgb"
    input.expect_function_matching("rgb")?;

    // Parse the contents inside rgb(...)
    input.parse_nested_block(|input| {
        let r = input.expect_integer()?;
        input.expect_comma()?;
        let g = input.expect_integer()?;
        input.expect_comma()?;
        let b = input.expect_integer()?;

        Ok((r as u8, g as u8, b as u8))
    })
}

// Example usage
let css = "rgb(255, 128, 0)";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);

match parse_rgb_function(&mut parser) {
    Ok((r, g, b)) => println!("RGB: ({}, {}, {})", r, g, b),
    Err(e) => println!("Parse error: {:?}", e),
}
// Output: RGB: (255, 128, 0)

// Parsing generic block contents
fn parse_curly_block(input: &mut Parser) -> Result<Vec<String>, ParseError<()>> {
    input.expect_curly_bracket_block()?;

    input.parse_nested_block(|input| {
        let mut values = Vec::new();
        while !input.is_exhausted() {
            if let Ok(ident) = input.expect_ident() {
                values.push(ident.to_string());
            } else {
                // Skip other tokens
                let _ = input.next();
            }
        }
        Ok(values)
    })
}

let css = "{ foo bar baz }" ;
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);
let values = parse_curly_block(&mut parser).unwrap();
println!("Block contents: {:?}", values); // Block contents: ["foo", "bar", "baz"]

```

--------------------------------

### CSS Syntax AST Node Representation (JSON)

Source: https://github.com/servo/rust-cssparser/blob/main/src/css-parsing-tests/README.rst

Illustrates the JSON representation of Abstract Syntax Tree (AST) nodes generated by the CSS parser. This compact representation distinguishes between different CSS constructs and their values.

```json
["at-keyword", "import"]
```

```json
["ident", "@import"]
```

```json
["at-rule", "charset", [["string", "utf-8"]], null]
```

```json
["qualified rule", [["ident", "body"]], [["declaration", "color", [["ident", "red"]], false]]]
```

```json
["declaration", "margin", [["dimension", "10px", 10, "number", "px"]], true]
```

```json
["ident", "color"]
```

```json
["hash", "main", "id"]
```

```json
["string", "Hello World"]
```

```json
["bad-string"]
```

```json
["url", "http://example.com"]
```

```json
["bad-url"]
```

```json
","
```

```json
["number", "10", 10, "integer"]
```

```json
["percentage", "50%", 50, "number"]
```

```json
["dimension", "2em", 2, "number", "em"]
```

```json
"~="
```

```json
"^="
```

```json
"*="
```

```json
" "
```

```json
"<!--"
```

```json
":"
```

```json
";"
```

```json
","
```

```json
["{}", [["ident", "padding"]]]
```

```json
["[]", [["ident", "text"]]]
```

```json
["()", [["ident", "margin"]]]
```

```json
["function", "calc", [["dimension", "100%", 100, "number", "%"]]]
```

```json
["error", "bad-string"]
```

```json
["error", "]"]
```

```json
["error", ")"]
```

--------------------------------

### Parse Complete CSS Stylesheet in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

This function demonstrates how to parse a complete CSS stylesheet using the `cssparser` library and custom rule parsers. It initializes the parser, iterates over the stylesheet results, and prints any parsed rules or errors. Requires `cssparser` crate.

```rust
use cssparser::{
    Parser, ParserInput, ParseError, CowRcStr, ParserState,
    AtRuleParser, QualifiedRuleParser, StyleSheetParser, Token
};

#[derive(Debug)]
struct Rule {
    selector: String,
    declarations: Vec<String>,
}

#[derive(Debug)]
struct AtRule {
    name: String,
    prelude: String,
}

struct MyRuleParser;

// (Assume AtRuleParser and QualifiedRuleParser implementations are above)
impl<'i> AtRuleParser<'i> for MyRuleParser {
    type Prelude = String;
    type AtRule = AtRule;
    type Error = ();

    fn parse_prelude<'t>(
        &mut self,
        name: CowRcStr<'i>,
        input: &mut Parser<'i, 't>,
    ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
        let mut prelude = Vec::new();
        while let Ok(token) = input.next() {
            match token {
                Token::Ident(s) => prelude.push(s.to_string()),
                _ => {} 
            }
        }
        Ok(prelude.join(" "))
    }

    fn rule_without_block(
        &mut self,
        _prelude: Self::Prelude,
        _start: &ParserState,
    ) -> Result<Self::AtRule, ()> {
        Err(())
    }

    fn parse_block<'t>(
        &mut self,
        prelude: Self::Prelude,
        _start: &ParserState,
        _input: &mut Parser<'i, 't>,
    ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> {
        Ok(AtRule {
            name: String::new(), 
            prelude,
        })
    }
}

impl<'i> QualifiedRuleParser<'i> for MyRuleParser {
    type Prelude = String;
    type QualifiedRule = Rule;
    type Error = ();

    fn parse_prelude<'t>(
        &mut self,
        input: &mut Parser<'i, 't>,
    ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
        let mut selector_parts = Vec::new();
        while let Ok(token) = input.next() {
            match token {
                Token::Ident(s) => selector_parts.push(s.to_string()),
                Token::Delim(c) => selector_parts.push(c.to_string()),
                Token::Hash(s) | Token::IDHash(s) => selector_parts.push(format!("#{}", s)),
                Token::Colon => selector_parts.push(":".to_string()),
                Token::LeftBracket => selector_parts.push("[".to_string()),
                Token::RightBracket => selector_parts.push("]".to_string()),
                Token::Dot => selector_parts.push(".".to_string()),
                _ => {} 
            }
        }
        Ok(selector_parts.join(""))
    }

    fn parse_block<'t>(
        &mut self,
        prelude: Self::Prelude,
        _start: &ParserState,
        input: &mut Parser<'i, 't>,
    ) -> Result<Self::QualifiedRule, ParseError<'i, Self::Error>> {
        let mut declarations = Vec::new();

        while !input.is_exhausted() {
            if let Ok(name) = input.try_parse(|input| input.expect_ident()) {
                let name = name.to_string();
                if input.expect_colon().is_ok() {
                    let mut value = Vec::new();
                    while let Ok(token) = input.next() {
                        match token {
                            Token::Semicolon => break,
                            Token::Ident(s) => value.push(s.to_string()),
                            Token::Colon => value.push(":".to_string()),
                            Token::Hash(s) | Token::IDHash(s) => value.push(format!("#{}", s)),
                            Token::Dimension { value, unit } => value.push(format!("{}{}", value, unit)),
                            _ => {} 
                        }
                    }
                    declarations.push(format!("{}: {}", name, value.join(" ")));
                }
            } else {
                let _ = input.next();
            }
        }

        Ok(Rule {
            selector: prelude,
            declarations,
        })
    }
}

// Parse a complete stylesheet
fn parse_stylesheet(css: &str) {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);
    let mut rule_parser = MyRuleParser;

    let stylesheet = StyleSheetParser::new(&mut parser, &mut rule_parser);

    for result in stylesheet {
        match result {
            Ok(rule) => println!("{:#?}", rule),
            Err((err, slice)) => println!("Parse error in: {}", slice),
        }
    }
}

// Example usage:
// let css = r#"#
//     body { color: red; margin: 0; } 
//     .container { width: 100%; } 
// "#;
// parse_stylesheet(css);

```

--------------------------------

### Implement Custom CSS AtRuleParser in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

This snippet shows how to implement the `AtRuleParser` trait from the `cssparser` crate to parse CSS at-rules. It defines how to parse the rule's prelude and its block, handling specific token types. Dependencies include the `cssparser` crate.

```rust
use cssparser::{
    Parser, ParserInput, ParseError, CowRcStr, ParserState,
    AtRuleParser, QualifiedRuleParser, StyleSheetParser, Token
};

#[derive(Debug)]
struct AtRule {
    name: String,
    prelude: String,
}

struct MyRuleParser;

impl<'i> AtRuleParser<'i> for MyRuleParser {
    type Prelude = String;
    type AtRule = AtRule;
    type Error = ();

    fn parse_prelude<'t>(
        &mut self,
        name: CowRcStr<'i>,
        input: &mut Parser<'i, 't>,
    ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
        // Parse the at-rule prelude (e.g., "screen" in @media screen)
        let mut prelude = Vec::new();
        while let Ok(token) = input.next() {
            match token {
                Token::Ident(s) => prelude.push(s.to_string()),
                _ => {} // Ignore other tokens for simplicity
            }
        }
        Ok(prelude.join(" "))
    }

    fn rule_without_block(
        &mut self,
        _prelude: Self::Prelude,
        _start: &ParserState,
    ) -> Result<Self::AtRule, ()> {
        // For at-rules without blocks like @import
        Err(())
    }

    fn parse_block<'t>(
        &mut self,
        prelude: Self::Prelude,
        _start: &ParserState,
        _input: &mut Parser<'i, 't>,
    ) -> Result<Self::AtRule, ParseError<'i, Self::Error>> {
        Ok(AtRule {
            name: String::new(), // Name is not parsed in this simplified example
            prelude,
        })
    }
}

```

--------------------------------

### Implement Custom CSS QualifiedRuleParser in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

This snippet demonstrates implementing the `QualifiedRuleParser` trait for parsing CSS qualified rules (e.g., selectors with declarations). It parses the selector prelude and the declarations within the rule's block. It relies on the `cssparser` crate.

```rust
use cssparser::{
    Parser, ParserInput, ParseError, CowRcStr, ParserState,
    AtRuleParser, QualifiedRuleParser, StyleSheetParser, Token
};

#[derive(Debug)]
struct Rule {
    selector: String,
    declarations: Vec<String>,
}

struct MyRuleParser;

impl<'i> QualifiedRuleParser<'i> for MyRuleParser {
    type Prelude = String;
    type QualifiedRule = Rule;
    type Error = ();

    fn parse_prelude<'t>(
        &mut self,
        input: &mut Parser<'i, 't>,
    ) -> Result<Self::Prelude, ParseError<'i, Self::Error>> {
        // Parse selector (simplified - just collect identifiers, delimiters, and hash)
        let mut selector_parts = Vec::new();
        while let Ok(token) = input.next() {
            match token {
                Token::Ident(s) => selector_parts.push(s.to_string()),
                Token::Delim(c) => selector_parts.push(c.to_string()),
                Token::Hash(s) | Token::IDHash(s) => selector_parts.push(format!("#{}", s)),
                Token::Colon => selector_parts.push(":".to_string()),
                Token::LeftBracket => selector_parts.push("[".to_string()),
                Token::RightBracket => selector_parts.push("]".to_string()),
                Token::Dot => selector_parts.push(".".to_string()),
                _ => {} // Ignore other tokens for simplicity
            }
        }
        Ok(selector_parts.join(""))
    }

    fn parse_block<'t>(
        &mut self,
        prelude: Self::Prelude,
        _start: &ParserState,
        input: &mut Parser<'i, 't>,
    ) -> Result<Self::QualifiedRule, ParseError<'i, Self::Error>> {
        // Parse declarations inside the rule block
        let mut declarations = Vec::new();

        while !input.is_exhausted() {
            if let Ok(name) = input.try_parse(|input| input.expect_ident()) {
                let name = name.to_string();
                if input.expect_colon().is_ok() {
                    let mut value = Vec::new();
                    while let Ok(token) = input.next() {
                        match token {
                            Token::Semicolon => break,
                            Token::Ident(s) => value.push(s.to_string()),
                            Token::Colon => value.push(":".to_string()),
                            Token::Hash(s) | Token::IDHash(s) => value.push(format!("#{}", s)),
                            Token::Dimension { value, unit } => value.push(format!("{}{}", value, unit)),
                            _ => {} // Ignore other tokens for simplicity
                        }
                    }
                    declarations.push(format!("{}: {}", name, value.join(" ")));
                }
            } else {
                // Consume tokens if not a declaration name to avoid infinite loops
                let _ = input.next();
            }
        }

        Ok(Rule {
            selector: prelude,
            declarations,
        })
    }
}

```

--------------------------------

### Handle CSS Parse Errors and Track Source Location in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

Demonstrates how to use `cssparser` in Rust to parse CSS, detect various parse errors (like unexpected tokens or end of input), and retrieve the source location (line and column) of these errors. It also shows how to break the parsing loop upon encountering an error.

```rust
use cssparser::{Parser, ParserInput, ParseError, ParseErrorKind, BasicParseErrorKind};

fn parse_with_error_handling(css: &str) {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);

    loop {
        // Get current location before parsing
        let start_location = parser.current_source_location();

        match parser.next() {
            Ok(token) => {
                println!("Token at line {}, col {}: {:?",
                         start_location.line, start_location.column, token);
            }
            Err(err) => {
                match &err.kind {
                    ParseErrorKind::Basic(basic_err) => {
                        match basic_err {
                            BasicParseErrorKind::UnexpectedToken(token) => {
                                println!("Unexpected token at line {}, col {}: {:?",
                                         err.location.line, err.location.column, token);
                            }
                            BasicParseErrorKind::EndOfInput => {
                                println!("End of input at line {}, col {}",
                                         err.location.line, err.location.column);
                                break;
                            }
                            BasicParseErrorKind::AtRuleInvalid(name) => {
                                println!("Invalid at-rule '{}' at line {}, col {}",
                                         name, err.location.line, err.location.column);
                            }
                            _ => println!("Parse error: {:?", err),
                        }
                    }
                    ParseErrorKind::Custom(_) => {
                        println!("Custom error at line {}, col {}",
                                 err.location.line, err.location.column);
                    }
                }
                break;
            }
        }
    }
}

// Example with multi-line CSS
let css = r#"
body {
    color: red;
    margin: 0;
}

.invalid ) {
    broken
}
"#;

parse_with_error_handling(css);

```

--------------------------------

### Rust: Expecting and Parsing Specific Token Types

Source: https://context7.com/servo/rust-cssparser/llms.txt

Illustrates how to use `expect` methods in rust-cssparser to parse and validate specific CSS token types, such as identifiers, colons, colors, numbers, and dimensions. This is useful for structured parsing of CSS declarations.

```rust
use cssparser::{Parser, ParserInput, ParseError};

fn parse_color_declaration(input: &mut Parser) -> Result<(String, String), ParseError<()>> {
    // Expect the property name "color"
    input.expect_ident_matching("color")?;

    // Expect colon
    input.expect_colon()?;

    // Expect a color value (identifier or string)
    let color = input.expect_ident_or_string()?.to_string();

    // Optionally expect semicolon
    let _ = input.expect_semicolon();

    Ok(("color".to_string(), color))
}

// Example usage
let css = "color: red;";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);

match parse_color_declaration(&mut parser) {
    Ok((prop, val)) => println!("{}: {}", prop, val),
    Err(e) => println!("Parse error at line {}, column {}", e.location.line, e.location.column),
}

// Parsing numbers and dimensions
fn parse_dimension(input: &mut Parser) -> Result<(f32, String), ParseError<()>> {
    let token = input.next()?.clone();
    match token {
        cssparser::Token::Dimension { value, unit, .. } => {
            Ok((value, unit.to_string()))
        }
        cssparser::Token::Number { value, .. } => {
            Ok((value, String::new()))
        }
        _ => Err(input.new_custom_error(()))?,
    }
}

let css = "10px";
let mut input = ParserInput::new(css);
let mut parser = Parser::new(&mut input);
let (num, unit) = parse_dimension(&mut parser).unwrap();
println!("Value: {}, Unit: {}", num, unit); // Value: 10, Unit: px

```

--------------------------------

### Implement Custom CSS Declaration Parsing in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

This Rust code implements the `DeclarationParser` trait to parse CSS declarations. It defines a `Declaration` struct to hold parsed data and a `MyDeclarationParser` struct to manage the parsing logic. The `parse_value` method handles token-based parsing of declaration values, and `parse_declarations` orchestrates the overall parsing process. It expects CSS as a string input and returns a vector of `Declaration` objects. Dependencies include the `cssparser` crate.

```rust
use cssparser::{
    DeclarationParser,
    Parser,
    ParserInput,
    ParseError,
    CowRcStr,
    ParserState,
    RuleBodyParser,
    Token
};

#[derive(Debug)]
struct Declaration {
    name: String,
    value: String,
    important: bool,
}

struct MyDeclarationParser;

impl<'i> DeclarationParser<'i> for MyDeclarationParser {
    type Declaration = Declaration;
    type Error = ();

    fn parse_value<'t>(
        &mut self,
        name: CowRcStr<'i>,
        input: &mut Parser<'i, 't>,
        _start: &ParserState,
    ) -> Result<Self::Declaration, ParseError<'i, Self::Error>> {
        let mut value_parts = Vec::new();

        while !input.is_exhausted() {
            let token = input.next()?;
            match token {
                Token::Ident(s) => value_parts.push(s.to_string()),
                Token::Number { value, .. } => value_parts.push(value.to_string()),
                Token::Dimension { value, unit, .. } => {
                    value_parts.push(format!("{}{}", value, unit));
                }
                Token::QuotedString(s) => value_parts.push(format!("\"{}\"", s)),
                Token::Hash(s) | Token::IDHash(s) => {
                    value_parts.push(format!("#{}", s));
                }
                _ => {}
            }
        }

        let value = value_parts.join(" ");

        Ok(Declaration {
            name: name.to_string(),
            value,
            important: false,
        })
    }
}

fn parse_declarations(css: &str) -> Vec<Declaration> {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);
    let mut decl_parser = MyDeclarationParser;

    RuleBodyParser::new(&mut parser, &mut decl_parser)
        .filter_map(|result| result.ok())
        .collect()
}

// Example usage
let css = "color: red; font-size: 14px; background: #fff;";
let declarations = parse_declarations(css);

for decl in declarations {
    println!("{}: {}", decl.name, decl.value);
}

```

--------------------------------

### Parse CSS nth-child Selectors (An+B Notation) in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

Parses CSS nth-child and nth-of-type selectors using the An+B notation with the cssparser library. It demonstrates how to extract the 'a' and 'b' values from patterns like '2n+1' or '3n+2'. The function handles various valid and invalid inputs, returning the parsed values or an error. It also shows how to integrate this parsing within a full CSS selector context.

```rust
use cssparser::{Parser, ParserInput, parse_nth};

fn parse_nth_selector(input: &str) -> Result<(i32, i32), Box<dyn std::error::Error>> {
    let mut parser_input = ParserInput::new(input);
    let mut parser = Parser::new(&mut parser_input);

    let (a, b) = parse_nth(&mut parser)?;
    Ok((a, b))
}

// Test various nth-child patterns
let test_cases = vec![
    ("2n+1", (2, 1)),      // odd elements
    ("2n", (2, 0)),        // even elements
    ("3n+2", (3, 2)),      // every 3rd starting at 2nd
    ("5", (0, 5)),         // 5th element only
    ("-n+3", (-1, 3)),     // first 3 elements
    ("n", (1, 0)),         // all elements
];

for (input, expected) in test_cases {
    match parse_nth_selector(input) {
        Ok((a, b)) => {
            println!("{} => An+B where A={}, B={}", input, a, b);
            assert_eq!((a, b), expected);
        }
        Err(e) => println!("Failed to parse {}: {}", input, e),
    }
}

// Using in :nth-child() context
fn parse_nth_child(css: &str) -> Result<(i32, i32), Box<dyn std::error::Error>> {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);

    // Expect :nth-child(
    parser.expect_colon()?;
    parser.expect_function_matching("nth-child")?;

    // Parse the An+B inside the function
    parser.parse_nested_block(|parser| {
        let (a, b) = parse_nth(parser)?;
        Ok((a, b))
    })
}

let css = ":nth-child(2n+1)";
match parse_nth_child(css) {
    Ok((a, b)) => println!("Matches elements at positions {}n+{}", a, b),
    Err(e) => println!("Error: {}", e),
}
// Output: Matches elements at positions 2n+1

```

--------------------------------

### Detect CSS Character Encoding in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

Detects the character encoding of a CSS stylesheet using the `cssparser` crate. It supports detection via Byte Order Mark (BOM), the `@charset` rule, and HTTP Content-Type headers. The implementation integrates with the `encoding_rs` crate for robust encoding handling and returns a UTF-8 decoded string. This is crucial for correctly interpreting CSS files with non-ASCII characters.

```rust
use cssparser::{stylesheet_encoding, EncodingSupport};

// Example implementation using encoding_rs
pub struct EncodingRs;

impl EncodingSupport for EncodingRs {
    type Encoding = &'static encoding_rs::Encoding;

    fn utf8() -> Self::Encoding {
        encoding_rs::UTF_8
    }

    fn is_utf16_be_or_le(encoding: &Self::Encoding) -> bool {
        *encoding == encoding_rs::UTF_16LE || *encoding == encoding_rs::UTF_16BE
    }

    fn from_label(ascii_label: &[u8]) -> Option<Self::Encoding> {
        encoding_rs::Encoding::for_label(ascii_label)
    }
}

// Detect encoding from bytes
fn decode_stylesheet(css_bytes: &[u8], http_encoding: Option<&str>) -> String {
    // Convert HTTP encoding label to bytes
    let protocol_label = http_encoding.map(|s| s.as_bytes());

    // Detect encoding (checks BOM, @charset, HTTP header, defaults to UTF-8)
    let encoding = stylesheet_encoding::<EncodingRs>(
        css_bytes,
        protocol_label,
        None, // No environment encoding
    );

    // Decode to UTF-8 string
    let (decoded, used_encoding, had_errors) = encoding.decode(css_bytes);

    println!("Detected encoding: {}", used_encoding.name());
    if had_errors {
        println!("Warning: Decoding had errors");
    }

    decoded.into_owned()
}

// Example with UTF-8 BOM
let css_with_bom = b"\xEF\xBB\xBFbody { color: red; }";
let decoded = decode_stylesheet(css_with_bom, None);
println!("CSS with BOM: {}", decoded);

// Example with @charset rule
let css_with_charset = b"@charset \"UTF-8\"; body { color: red; }";
let decoded = decode_stylesheet(css_with_charset, None);
println!("CSS with @charset: {}", decoded);

// Example with HTTP header
let css_bytes = b"body { color: red; }";
let decoded = decode_stylesheet(css_bytes, Some("utf-8"));
println!("CSS with HTTP header: {}", decoded);

// Example with Latin-1 encoding
let css_latin1 = b"@charset \"ISO-8859-1\"; body { content: \"\xc9\"; }"; // \xc9 is 'É' in Latin-1
let decoded = decode_stylesheet(css_latin1, None);
println!("CSS with Latin-1: {}", decoded);

```

--------------------------------

### Parse CSS Declarations with !important in Rust

Source: https://context7.com/servo/rust-cssparser/llms.txt

Parses a CSS declaration string, extracting the property name, value, and whether the '!important' flag is present. It handles basic token types for values and relies on the `cssparser` crate. This function is useful for advanced CSS processing where the !important status needs to be programmatically determined.

```rust
use cssparser::{Parser, ParserInput, parse_important, ParseError};

fn parse_declaration_with_important(css: &str) -> Result<(String, String, bool), ParseError<()>> {
    let mut input = ParserInput::new(css);
    let mut parser = Parser::new(&mut input);

    // Parse property name
    let name = parser.expect_ident()?.to_string();
    parser.expect_colon()?;

    // Parse value
    let mut value_parts = Vec::new();
    loop {
        // Try to parse !important
        if parse_important(&mut parser).is_ok() {
            return Ok((name, value_parts.join(" "), true));
        }

        // Check for end of declaration
        if parser.is_exhausted() {
            return Ok((name, value_parts.join(" "), false));
        }

        // Parse value token
        let token = parser.next()?;
        match token {
            cssparser::Token::Ident(s) => value_parts.push(s.to_string()),
            cssparser::Token::Number { value, .. } => value_parts.push(value.to_string()),
            cssparser::Token::Dimension { value, unit, .. } => {
                value_parts.push(format!("{}{}", value, unit));
            }
            _ => {} // Ignore other token types for simplicity
        }
    }
}

// Test with and without !important
let test_cases = vec![
    "color: red",
    "color: red !important",
    "font-size: 14px !important",
    "margin: 0",
];

for css in test_cases {
    match parse_declaration_with_important(css) {
        Ok((name, value, important)) => {
            println!("{}: {} {}", name, value, if important { "!important" } else { "" });
        }
        Err(e) => println!("Parse error: {:?}", e),
    }
}
// Expected Output:
// color: red 
// color: red !important
// font-size: 14px !important
// margin: 0 

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.