raffia 0.12.2

One parser for CSS/SCSS/Sass/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

use crate::Span;
use smallvec::SmallVec;
use std::borrow::Cow;

/// Compare equality of two AST nodes without respecting their spans.
///
/// This allows to compare AST nodes content
/// while they're in different locations of syntax tree.
pub trait SpanIgnoredEq {
    /// Compare equality of two AST nodes without respecting their spans.
    #[must_use]
    fn span_ignored_eq(&self, other: &Self) -> bool;
}

impl SpanIgnoredEq for str {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for &str {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for String {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for Cow<'_, str> {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for Span {
    #[inline]
    fn span_ignored_eq(&self, _: &Self) -> bool {
        true
    }
}

impl SpanIgnoredEq for f32 {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for i32 {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for u32 {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for bool {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl SpanIgnoredEq for char {
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self == other
    }
}

impl<T> SpanIgnoredEq for Vec<T>
where
    T: SpanIgnoredEq,
{
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self.len() == other.len()
            && self
                .iter()
                .zip(other.iter())
                .all(|(a, b)| a.span_ignored_eq(b))
    }
}

impl<T, const N: usize> SpanIgnoredEq for SmallVec<[T; N]>
where
    T: SpanIgnoredEq,
{
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self.len() == other.len()
            && self
                .iter()
                .zip(other.iter())
                .all(|(a, b)| a.span_ignored_eq(b))
    }
}

impl<T> SpanIgnoredEq for Option<T>
where
    T: SpanIgnoredEq,
{
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Some(a), Some(b)) => a.span_ignored_eq(b),
            (None, None) => true,
            _ => false,
        }
    }
}

impl<T> SpanIgnoredEq for Box<T>
where
    T: SpanIgnoredEq,
{
    #[inline]
    fn span_ignored_eq(&self, other: &Self) -> bool {
        self.as_ref().span_ignored_eq(other.as_ref())
    }
}