oxc-css-parser 0.0.3

Parser for CSS, SCSS, Sass, and Less.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#[doc(hidden)]
#[macro_export]
macro_rules! bump {
    ($parser:expr) => {{
        match $parser.cached_token.take() {
            Some(token_with_span) => token_with_span,
            None => {
                let tokenizer = &mut $parser.tokenizer;
                tokenizer.bump()?
            }
        }
    }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! expect {
    ($parser:expr, $variant:ident) => {{
        use $crate::{
            bump,
            error::{Error, ErrorKind},
            tokenizer::{Token, TokenSymbol, TokenWithSpan},
        };
        match bump!($parser) {
            TokenWithSpan { token: Token::$variant(token), span } => (token, span),
            TokenWithSpan { token, span } => {
                return Err(Error {
                    kind: ErrorKind::Unexpected(
                        $crate::tokenizer::token::$variant::symbol(),
                        token.symbol(),
                    ),
                    span,
                });
            }
        }
    }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! expect_without_ws_or_comments {
    ($parser:expr, Ident) => {{
        use $crate::{
            error::{Error, ErrorKind},
            tokenizer::TokenSymbol,
        };
        debug_assert!($parser.cached_token.is_none());
        let tokenizer = &mut $parser.tokenizer;
        if tokenizer.is_start_of_ident() {
            tokenizer.scan_ident_sequence()?
        } else {
            let token_with_span = tokenizer.bump_without_ws_or_comments()?;
            return Err(Error {
                kind: ErrorKind::Unexpected(
                    $crate::tokenizer::token::Ident::symbol(),
                    token_with_span.token.symbol(),
                ),
                span: token_with_span.span,
            });
        }
    }};
    ($parser:expr, $variant:ident) => {{
        use $crate::{
            error::{Error, ErrorKind},
            tokenizer::{Token, TokenSymbol, TokenWithSpan},
        };
        debug_assert!($parser.cached_token.is_none());
        let tokenizer = &mut $parser.tokenizer;
        let token_with_span = tokenizer.bump_without_ws_or_comments()?;
        match token_with_span {
            TokenWithSpan { token: Token::$variant(token), span } => (token, span),
            TokenWithSpan { token, span } => {
                return Err(Error {
                    kind: ErrorKind::Unexpected(
                        $crate::tokenizer::token::$variant::symbol(),
                        token.symbol(),
                    ),
                    span,
                });
            }
        }
    }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! eat {
    ($parser:expr, $variant:ident) => {{
        use $crate::{
            bump,
            tokenizer::{Token, TokenWithSpan},
        };
        let token_with_span = bump!($parser);
        match token_with_span {
            TokenWithSpan { token: Token::$variant(token), span } => Some((token, span)),
            value => {
                $parser.cached_token = Some(value);
                None
            }
        }
    }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! peek {
    ($parser:expr) => {{
        match &$parser.cached_token {
            Some(token_with_span) => token_with_span,
            None => {
                let tokenizer = &mut $parser.tokenizer;
                let token = tokenizer.bump()?;
                $parser.cached_token.insert(token)
            }
        }
    }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! arena_box {
    ($parser:expr, $value:expr) => {{ oxc_allocator::Box::new_in($value, &$parser.allocator()) }};
}

#[doc(hidden)]
#[macro_export]
macro_rules! arena_vec {
    ($parser:expr) => {{
        oxc_allocator::Vec::new_in(&$parser.allocator())
    }};
    ($parser:expr; $($value:expr),+ $(,)?) => {{
        let mut vec = oxc_allocator::Vec::with_capacity_in(
            <[()]>::len(&[$($crate::arena_vec!(@unit $value)),+]),
            &$parser.allocator(),
        );
        $(vec.push($value);)+
        vec
    }};
    (@unit $value:expr) => {
        ()
    };
}