peacock_crest/selector/
mod.rs

1mod pest_selector;
2mod types;
3
4pub use pest_selector::Rule as SelectorRule;
5pub use types::{SelectorAttributeType, SelectorCombinator, SelectorResult};
6
7pub(crate) use pest_selector::SelectorParser;
8pub(crate) use types::{SelectorExpectError, SelectorSubclassType};
9
10use std::cell::Cell;
11use std::collections::HashMap;
12use std::sync::Arc;
13
14use crate::boo::Boo;
15use crate::source::{parse_source, ParserToken, SourceInfo, SourceSlice, StackInfo, TokenTracker};
16use crate::syntax::CssToken;
17use crate::Unit;
18
19pub(crate) type SelectorToken = ParserToken<SelectorRule>;
20pub(crate) type SelectorStackInfo = StackInfo<SelectorRule>;
21
22#[derive(Debug, Clone)]
23pub enum SelectorNodeType {
24    Namespace(String),
25    Universal,
26    TypeName(String),
27    Id(String),
28    Class(String),
29    Attribute {
30        name: String,
31        attr_matcher: SelectorAttributeType,
32        case_sensitive: bool,
33    },
34    NextSibling(Box<SelectorNode>),
35    SubsequentSibling(Box<SelectorNode>),
36    Child(Box<SelectorNode>),
37    Descendent(Box<SelectorNode>),
38    PseudoClass(String),
39    PseudoElement(String, Option<Box<[Unit]>>),
40}
41
42#[derive(Debug, Clone, Default)]
43pub struct SelectorNode(Vec<SelectorNodeType>);
44
45#[derive(Debug, Clone)]
46pub struct SelectorTokenTracker<'a>(crate::source::TokenTracker<'a, SelectorRule>);
47
48impl<'a> SelectorTokenTracker<'a> {
49    #[inline]
50    pub fn new(selector_token: &'a SelectorToken) -> Option<SelectorTokenTracker<'a>> {
51        selector_token
52            .get_children()
53            .map(|x| Self(TokenTracker::new(Boo::Borrowed(x))))
54    }
55
56    #[inline]
57    pub fn from_vec(vec: &'a Vec<SelectorToken>) -> Self {
58        Self(TokenTracker::new(Boo::Borrowed(vec)))
59    }
60
61    #[inline]
62    fn fail_type<O>(&self, expected: SelectorRule) -> SelectorResult<O> {
63        let current_rule = self.boo.get(0.max(self.idx.get() - 1)).unwrap().get_rule();
64        self.0.fail_because(SelectorExpectError::FailedExpectation(
65            current_rule,
66            expected,
67        ))
68    }
69
70    /// Consumes the next token, constructs a `Box<[crate::SelectorNode]>` representation
71    /// if it is a valid selector token. Returns an `SelectorExpectError` otherwise.
72    pub fn expect_selector_list(&'a self) -> SelectorResult<Box<[SelectorNode]>> {
73        let token: &SelectorToken = self
74            .pop_front()
75            .ok_or(SelectorExpectError::TooFewTokens("SELECTOR_LIST".into()))?;
76
77        if !matches!(token.get_rule(), SelectorRule::SELECTOR_LIST) {
78            return self.fail_type(SelectorRule::SELECTOR_LIST);
79        }
80
81        // SELF: SELECTOR_LIST -> SELECTOR_COMPLEX_LIST [ children ]
82        let list_expector = Self::new(&token.get_children().unwrap()[0]).unwrap();
83
84        let mut selectors: Vec<SelectorNode> = Vec::new();
85
86        while let Ok((mut first, mut rest)) = list_expector.expect_complex() {
87            while rest.len() > 1 {
88                let combinator = rest.pop().unwrap();
89                let prev = rest.last_mut().unwrap().get_node();
90                match combinator {
91                    SelectorCombinator::SubsequentSibling(selector_node) => {
92                        prev.push(SelectorNodeType::SubsequentSibling(Box::new(selector_node)))
93                    }
94                    SelectorCombinator::NextSibling(selector_node) => {
95                        prev.push(SelectorNodeType::NextSibling(Box::new(selector_node)))
96                    }
97                    SelectorCombinator::Descendent(selector_node) => {
98                        prev.push(SelectorNodeType::Descendent(Box::new(selector_node)))
99                    }
100                    SelectorCombinator::Column(selector_node) => todo!(),
101                    SelectorCombinator::Child(selector_node) => {
102                        prev.push(SelectorNodeType::Child(Box::new(selector_node)))
103                    }
104                }
105            }
106
107            if !rest.is_empty() {
108                let combinator = rest.pop().unwrap();
109                match combinator {
110                    SelectorCombinator::SubsequentSibling(selector_node) => {
111                        first.push(SelectorNodeType::SubsequentSibling(Box::new(selector_node)))
112                    }
113                    SelectorCombinator::NextSibling(selector_node) => {
114                        first.push(SelectorNodeType::NextSibling(Box::new(selector_node)))
115                    }
116                    SelectorCombinator::Descendent(selector_node) => {
117                        first.push(SelectorNodeType::Descendent(Box::new(selector_node)))
118                    }
119                    SelectorCombinator::Column(selector_node) => todo!(),
120                    SelectorCombinator::Child(selector_node) => {
121                        first.push(SelectorNodeType::Child(Box::new(selector_node)))
122                    }
123                }
124            }
125
126            selectors.push(first);
127        }
128
129        Ok(selectors.into_boxed_slice())
130    }
131
132    pub fn expect_complex(&'a self) -> SelectorResult<(SelectorNode, Vec<SelectorCombinator>)> {
133        let token: &SelectorToken = self
134            .pop_front()
135            .ok_or(SelectorExpectError::TooFewTokens("SELECTOR_COMPLEX".into()))?;
136
137        if !matches!(token.get_rule(), SelectorRule::SELECTOR_COMPLEX) {
138            return self.fail_type(SelectorRule::SELECTOR_COMPLEX);
139        }
140
141        let complex_expector = Self::new(token).unwrap();
142
143        let first = complex_expector.expect_compound()?;
144        let mut rest: Vec<SelectorCombinator> = Vec::new();
145
146        while let Some(peek) = complex_expector.peek() {
147            match peek.get_rule() {
148                SelectorRule::SELECTOR_COMBINATOR => {
149                    let combinator_token = complex_expector.pop_front().unwrap();
150
151                    let next = complex_expector.expect_compound()?;
152
153                    let combinator_components = combinator_token.get_children().unwrap();
154                    let combinator: SelectorCombinator = match combinator_components[0].get_rule() {
155                        SelectorRule::SELECTOR_COMBINATOR__NEXT_SIBLING => {
156                            SelectorCombinator::NextSibling(next)
157                        }
158                        SelectorRule::SELECTOR_COMBINATOR__CHILD => SelectorCombinator::Child(next),
159                        SelectorRule::SELECTOR_COMBINATOR__COLUMN => {
160                            SelectorCombinator::Column(next)
161                        }
162                        SelectorRule::SELECTOR_COMBINATOR__SUBSEQUENT_SIBLING => {
163                            SelectorCombinator::SubsequentSibling(next)
164                        }
165                        SelectorRule::SELECTOR_COMBINATOR__DESCENDENT => {
166                            SelectorCombinator::Descendent(next)
167                        }
168
169                        _ => unreachable!(),
170                    };
171
172                    rest.push(combinator);
173                }
174                SelectorRule::SELECTOR_COMBINATOR__NAMESPACE => {
175                    let namespace_token = complex_expector.pop_front().unwrap();
176                    let node =
177                        SelectorNodeType::Namespace(namespace_token.get_source().to_string());
178                    rest.last_mut().unwrap().get_node().push(node);
179                }
180
181                _ => unreachable!(),
182            }
183        }
184
185        Ok((first, rest))
186    }
187
188    pub fn expect_compound(&'a self) -> SelectorResult<SelectorNode> {
189        let token: &SelectorToken = self.pop_front().ok_or(SelectorExpectError::TooFewTokens(
190            "SELECTOR_COMPOUND".into(),
191        ))?;
192
193        if !matches!(token.get_rule(), SelectorRule::SELECTOR_COMPOUND) {
194            return self.fail_type(SelectorRule::SELECTOR_COMPOUND);
195        }
196
197        let compound_expector = Self::new(token).unwrap();
198        let mut node = SelectorNode::default();
199
200        if let Ok((namespace_opt, type_name_opt)) = compound_expector.expect_type() {
201            if namespace_opt.is_none() && type_name_opt.is_none() {
202                node.push(SelectorNodeType::Universal);
203            } else {
204                if let Some(namespace) = namespace_opt {
205                    node.push(SelectorNodeType::Namespace(namespace.to_string()));
206                }
207                if let Some(type_name) = type_name_opt {
208                    node.push(SelectorNodeType::TypeName(type_name.to_string()));
209                }
210            }
211        }
212
213        while let Ok(subclass) = compound_expector.expect_subclass() {
214            match subclass {
215                SelectorSubclassType::Id(id) => node.push(SelectorNodeType::Id(id)),
216                SelectorSubclassType::Class(class) => node.push(SelectorNodeType::Class(class)),
217                SelectorSubclassType::Attribute {
218                    name,
219                    attr_matcher,
220                    case_sensitive,
221                } => node.push(SelectorNodeType::Attribute {
222                    name,
223                    attr_matcher,
224                    case_sensitive,
225                }),
226                SelectorSubclassType::PseudoClass(psclass) => {
227                    node.push(SelectorNodeType::PseudoClass(psclass))
228                }
229                SelectorSubclassType::PseudoElement(pselement, params) => {
230                    node.push(SelectorNodeType::PseudoElement(pselement, params))
231                }
232            }
233        }
234
235        Ok(node)
236    }
237
238    fn expect_subclass(&'a self) -> SelectorResult<SelectorSubclassType> {
239        let token: &SelectorToken = self.pop_front().ok_or(SelectorExpectError::TooFewTokens(
240            "SELECTOR_SUBCLASS".into(),
241        ))?;
242
243        if !matches!(token.get_rule(), SelectorRule::SELECTOR_SUBCLASS) {
244            return self.fail_type(SelectorRule::SELECTOR_SUBCLASS);
245        }
246
247        let subclass_expector = Self::new(token).unwrap();
248        match subclass_expector.peek().unwrap().get_rule() {
249            SelectorRule::SELECTOR_ID => {
250                let ident = subclass_expector.expect_id()?;
251
252                Ok(SelectorSubclassType::Id(ident.to_string()))
253            }
254            SelectorRule::SELECTOR_CLASS => {
255                let ident = subclass_expector.expect_class()?;
256
257                Ok(SelectorSubclassType::Class(ident.to_string()))
258            }
259            SelectorRule::SELECTOR_ATTRIBUTE => {
260                let (name, attr_matcher, case_sensitive) = subclass_expector.expect_attribute()?;
261
262                Ok(SelectorSubclassType::Attribute {
263                    name: name.to_string(),
264                    attr_matcher,
265                    case_sensitive,
266                })
267            }
268            SelectorRule::SELECTOR_PSEUDOCLASS => {
269                let psclass = subclass_expector.expect_pseudoclass()?;
270
271                Ok(SelectorSubclassType::PseudoClass(psclass.to_string()))
272            }
273
274            _ => unreachable!(),
275        }
276    }
277
278    fn expect_pseudoclass(&'a self) -> SelectorResult<SourceSlice> {
279        let token: &SelectorToken = self.pop_front().ok_or(SelectorExpectError::TooFewTokens(
280            "SELECTOR_PSEUDOCLASS".into(),
281        ))?;
282
283        if !matches!(token.get_rule(), SelectorRule::SELECTOR_PSEUDOCLASS) {
284            return self.fail_type(SelectorRule::SELECTOR_PSEUDOCLASS);
285        }
286
287        let psclass_expector = Self::new(token).unwrap();
288        match psclass_expector.peek().unwrap().get_rule() {
289            SelectorRule::IDENT => {
290                let ident = psclass_expector.expect_identifier()?;
291                Ok(ident)
292            }
293            SelectorRule::FUNCTION => todo!("Functions are not currently supported"),
294
295            _ => unreachable!(),
296        }
297    }
298
299    fn expect_id(&'a self) -> SelectorResult<SourceSlice> {
300        let token: &SelectorToken = self
301            .pop_front()
302            .ok_or(SelectorExpectError::TooFewTokens("SELECTOR_ID".into()))?;
303
304        if !matches!(token.get_rule(), SelectorRule::SELECTOR_ID) {
305            return self.fail_type(SelectorRule::SELECTOR_ID);
306        }
307
308        let id_expector = Self::new(token).unwrap();
309
310        id_expector.expect_hash()
311    }
312
313    /// Consumes the next token and extracts its `SourceSlice` representation if it is a
314    /// valid hash token. Returns a `CssExpectError` otherwise.
315    pub fn expect_hash(&self) -> SelectorResult<SourceSlice> {
316        let token: &SelectorToken = self
317            .pop_front()
318            .ok_or(SelectorExpectError::TooFewTokens("HASH".into()))?;
319
320        if !matches!(token.get_rule(), SelectorRule::HASH) {
321            return self.fail_type(SelectorRule::HASH);
322        }
323
324        let mut slice = token.get_source();
325        slice.start = slice.source_info.location_from_idx(slice.start.idx + 1);
326
327        Ok(slice)
328    }
329
330    pub fn expect_class(&'a self) -> SelectorResult<SourceSlice> {
331        let token: &SelectorToken = self
332            .pop_front()
333            .ok_or(SelectorExpectError::TooFewTokens("SELECTOR_CLASS".into()))?;
334
335        if !matches!(token.get_rule(), SelectorRule::SELECTOR_CLASS) {
336            return self.fail_type(SelectorRule::SELECTOR_CLASS);
337        }
338
339        let class_expector = Self::new(token).unwrap();
340
341        class_expector.expect_identifier()
342    }
343
344    fn expect_attribute(&'a self) -> SelectorResult<(SourceSlice, SelectorAttributeType, bool)> {
345        let token: &SelectorToken = self.pop_front().ok_or(SelectorExpectError::TooFewTokens(
346            "SELECTOR_ATTRIBUTE".into(),
347        ))?;
348
349        if !matches!(token.get_rule(), SelectorRule::SELECTOR_ATTRIBUTE) {
350            return self.fail_type(SelectorRule::SELECTOR_ATTRIBUTE);
351        }
352
353        let attribute_expector = Self::new(token).unwrap();
354
355        let attr_name = attribute_expector.expect_identifier()?;
356        let matcher_result = attribute_expector
357            .expect_attr_matcher()
358            .unwrap_or(SelectorAttributeType::Present);
359        let sens = attribute_expector.expect_attr_modifier().unwrap_or(false);
360
361        Ok((attr_name, matcher_result, sens))
362    }
363
364    fn expect_attr_matcher(&'a self) -> SelectorResult<SelectorAttributeType> {
365        let token: &SelectorToken = self
366            .pop_front()
367            .ok_or(SelectorExpectError::TooFewTokens("ATTR_MATCHER".into()))?;
368
369        if !matches!(token.get_rule(), SelectorRule::ATTR_MATCHER) {
370            return self.fail_type(SelectorRule::ATTR_MATCHER);
371        }
372
373        let matcher_expector = Self::new(token).unwrap();
374
375        let matcher_type = matcher_expector
376            .pop_front()
377            .ok_or(SelectorExpectError::TooFewTokens("ATTR_MATCHER".into()))?;
378
379        let matcher_value = match matcher_expector.peek().unwrap().get_rule() {
380            SelectorRule::STRING => matcher_expector.expect_quoted_string()?,
381            SelectorRule::IDENT => matcher_expector.expect_identifier()?,
382
383            _ => unreachable!(),
384        };
385
386        match matcher_type.get_rule() {
387            SelectorRule::ATTR_MATCHER__EXACT_MATCH => {
388                Ok(SelectorAttributeType::ExactMatch(matcher_value.to_string()))
389            }
390            SelectorRule::ATTR_MATCHER__LIST_CONTAINS => Ok(SelectorAttributeType::ListContains(
391                matcher_value.to_string(),
392            )),
393            SelectorRule::ATTR_MATCHER__STARTS_WITH => {
394                Ok(SelectorAttributeType::StartsWith(matcher_value.to_string()))
395            }
396            SelectorRule::ATTR_MATCHER__STARTS_WITH_DASHED => Ok(
397                SelectorAttributeType::StartsWithDashed(matcher_value.to_string()),
398            ),
399            SelectorRule::ATTR_MATCHER__ENDS_WITH => {
400                Ok(SelectorAttributeType::Endswith(matcher_value.to_string()))
401            }
402            SelectorRule::ATTR_MATCHER__CONTAINS => Ok(SelectorAttributeType::RawContains(
403                matcher_value.to_string(),
404            )),
405
406            _ => unreachable!(),
407        }
408    }
409
410    fn expect_attr_modifier(&self) -> SelectorResult<bool> {
411        let token: &SelectorToken = self
412            .pop_front()
413            .ok_or(SelectorExpectError::TooFewTokens("ATTR_MODIFIER".into()))?;
414
415        if !matches!(token.get_rule(), SelectorRule::ATTR_MODIFIER) {
416            return self.fail_type(SelectorRule::ATTR_MODIFIER);
417        }
418
419        match token.get_source().get() {
420            "s" | "S" => Ok(true),
421            "i" | "I" => Ok(false),
422
423            _ => unreachable!(),
424        }
425    }
426
427    // namespace, name
428    fn expect_type(&'a self) -> SelectorResult<(Option<SourceSlice>, Option<SourceSlice>)> {
429        let token: &SelectorToken = self
430            .pop_front()
431            .ok_or(SelectorExpectError::TooFewTokens("SELECTOR_TYPE".into()))?;
432
433        if !matches!(token.get_rule(), SelectorRule::SELECTOR_TYPE) {
434            return self.fail_type(SelectorRule::SELECTOR_TYPE);
435        }
436
437        if let Some(type_expector) = Self::new(token) {
438            match type_expector.peek().unwrap().get_rule() {
439                SelectorRule::PREFIX_NAMESPACE => {
440                    let namespace = type_expector.expect_prefix_namespace()?;
441                    Ok((namespace, None))
442                }
443                SelectorRule::WQ_NAME => {
444                    let (namespace, name) = type_expector.expect_wq_name()?;
445                    Ok((namespace, Some(name)))
446                }
447
448                _ => unreachable!(),
449            }
450        } else {
451            Ok((None, None))
452        }
453    }
454
455    // namespace, name
456    pub fn expect_wq_name(&'a self) -> SelectorResult<(Option<SourceSlice>, SourceSlice)> {
457        let token: &SelectorToken = self
458            .pop_front()
459            .ok_or(SelectorExpectError::TooFewTokens("WQ_NAME".into()))?;
460
461        if !matches!(token.get_rule(), SelectorRule::WQ_NAME) {
462            return self.fail_type(SelectorRule::WQ_NAME);
463        }
464
465        let wq_expector = Self::new(token).unwrap();
466
467        match wq_expector.peek().unwrap().get_rule() {
468            SelectorRule::PREFIX_NAMESPACE => {
469                let prefix = wq_expector.expect_prefix_namespace()?;
470                let ident = wq_expector.expect_identifier()?;
471                Ok((prefix, ident))
472            }
473            SelectorRule::IDENT => {
474                let ident = wq_expector.expect_identifier()?;
475                Ok((None, ident))
476            }
477
478            _ => unreachable!(),
479        }
480    }
481
482    pub fn expect_prefix_namespace(&'a self) -> SelectorResult<Option<SourceSlice>> {
483        let token: &SelectorToken = self
484            .pop_front()
485            .ok_or(SelectorExpectError::TooFewTokens("PREFIX_NAMESPACE".into()))?;
486
487        if !matches!(token.get_rule(), SelectorRule::PREFIX_NAMESPACE) {
488            return self.fail_type(SelectorRule::PREFIX_NAMESPACE);
489        }
490
491        if let Some(namespace_expector) = Self::new(token) {
492            let namespace = namespace_expector.expect_identifier()?;
493            Ok(Some(namespace))
494        } else {
495            Ok(None)
496        }
497    }
498
499    /// Consumes the next token and extracts its `SourceSlice` representation if it is a valid
500    /// identifier. Returns an `SelectorExpectError` otherwise.
501    pub fn expect_identifier(&self) -> SelectorResult<SourceSlice> {
502        let token: &SelectorToken = self
503            .pop_front()
504            .ok_or(SelectorExpectError::TooFewTokens("IDENT".into()))?;
505
506        if !matches!(token.get_rule(), SelectorRule::IDENT) {
507            return self.fail_type(SelectorRule::IDENT);
508        }
509
510        Ok(token.get_source())
511    }
512
513    /// Consumes the next token and extracts its `SourceSlice` representation if it is a valid quoted
514    /// string token. Excludes surrounding quotes from the result. Returns an `SelectorExpectError` otherwise.
515    pub fn expect_quoted_string(&self) -> SelectorResult<SourceSlice> {
516        let token: &SelectorToken = self
517            .pop_front()
518            .ok_or(SelectorExpectError::TooFewTokens("STRING".into()))?;
519
520        if !matches!(token.get_rule(), SelectorRule::STRING) {
521            return self.fail_type(SelectorRule::STRING);
522        }
523
524        let mut slice = token.get_source();
525        slice.start = slice.source_info.location_from_idx(slice.start.idx + 1);
526        slice.end = slice.source_info.location_from_idx(slice.end.idx - 1);
527
528        Ok(slice)
529    }
530}
531
532impl SelectorNode {
533    pub fn from_source(source_info: SourceInfo) -> Result<Box<[Self]>, SelectorExpectError> {
534        let selector_parser_result = parse_source::<SelectorRule, SelectorParser>(
535            source_info.into(),
536            SelectorRule::SELECTOR_LIST,
537        );
538
539        let selector_parser =
540            selector_parser_result.map_err(|err| SelectorExpectError::ParseError(err))?;
541        let selector_expector = SelectorTokenTracker::new(&selector_parser).unwrap();
542
543        Ok(selector_expector.expect_selector_list()?)
544    }
545}
546
547impl std::ops::Deref for SelectorNode {
548    type Target = Vec<SelectorNodeType>;
549
550    fn deref(&self) -> &Self::Target {
551        &self.0
552    }
553}
554
555impl std::ops::DerefMut for SelectorNode {
556    fn deref_mut(&mut self) -> &mut Self::Target {
557        &mut self.0
558    }
559}
560
561impl std::fmt::Display for SelectorNode {
562    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
563        for node in self.iter() {
564            match node {
565                SelectorNodeType::Universal => write!(f, "*"),
566                SelectorNodeType::Namespace(namespace) => write!(f, "|{namespace}"),
567                SelectorNodeType::TypeName(type_name) => write!(f, "{type_name}"),
568                SelectorNodeType::Id(id) => write!(f, "#{id}"),
569                SelectorNodeType::Class(class) => write!(f, ".{class}"),
570                SelectorNodeType::Attribute {
571                    name,
572                    attr_matcher,
573                    case_sensitive,
574                } => {
575                    write!(f, "[{name}");
576                    match attr_matcher {
577                        SelectorAttributeType::ExactMatch(attr) => write!(f, r#"="{attr}""#),
578                        SelectorAttributeType::ListContains(attr) => write!(f, r#"~="{attr}""#),
579                        SelectorAttributeType::StartsWith(attr) => write!(f, r#"^="{attr}""#),
580                        SelectorAttributeType::StartsWithDashed(attr) => write!(f, r#"|="{attr}""#),
581                        SelectorAttributeType::Endswith(attr) => write!(f, r#"$="{attr}""#),
582                        SelectorAttributeType::RawContains(attr) => write!(f, r#"*="{attr}""#),
583
584                        SelectorAttributeType::Present => Ok(()),
585                    };
586                    write!(f, "]")
587                }
588                SelectorNodeType::NextSibling(sibling) => write!(f, " + {sibling}"),
589                SelectorNodeType::SubsequentSibling(sibling) => write!(f, " ~ {sibling}"),
590                SelectorNodeType::Child(child) => write!(f, " > {child}"),
591                SelectorNodeType::Descendent(descendent) => write!(f, " {descendent}"),
592                SelectorNodeType::PseudoClass(psclass) => write!(f, ":{psclass}"),
593                SelectorNodeType::PseudoElement(pselement, params_opt) => {
594                    write!(f, "::{pselement}");
595                    if let Some(params) = params_opt {
596                        let list: String = params
597                            .as_ref()
598                            .iter()
599                            .map(|x| x.to_string())
600                            .collect::<Vec<_>>()
601                            .join(", ");
602                        write!(f, "({list})");
603                    }
604                    Ok(())
605                }
606            };
607        }
608
609        Ok(())
610    }
611}
612
613impl<'a> std::ops::Deref for SelectorTokenTracker<'a> {
614    type Target = crate::source::TokenTracker<'a, SelectorRule>;
615
616    fn deref(&self) -> &Self::Target {
617        &self.0
618    }
619}
peacock_crest/selector/mod.rs

peacock_crest/selector/
mod.rs
