Quellcode-Bibliothek parser.rs

/* 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 https://mozilla.org/MPL/2.0/. */

use crate::attr::{AttrSelectorOperator, AttrSelectorWithOptionalNamespace};
use crate::attr::{NamespaceConstraint, ParsedAttrSelectorOperation, ParsedCaseSensitivity};
use crate::bloom::BLOOM_HASH_MASK;
use crate::builder::{
    relative_selector_list_specificity_and_flags, selector_list_specificity_and_flags,
    SelectorBuilder, SelectorFlags, Specificity, SpecificityAndFlags,
};
use crate::context::QuirksMode;
use crate::sink::Push;
use crate::visitor::SelectorListKind;
pub use crate::visitor::SelectorVisitor;
use bitflags::bitflags;
use cssparser::match_ignore_ascii_case;
use cssparser::parse_nth;
use cssparser::{BasicParseError, BasicParseErrorKind, ParseError, ParseErrorKind};
use cssparser::{CowRcStr, Delimiter, SourceLocation};
use cssparser::{Parser as CssParser, ToCss, Token};
use debug_unreachable::debug_unreachable;
use precomputed_hash::PrecomputedHash;
use servo_arc::{Arc, ArcUnionBorrow, ThinArc, ThinArcUnion, UniqueArc};
use smallvec::SmallVec;
use std::borrow::{Borrow, Cow};
use std::fmt::{self, Debug};
use std::iter::Rev;
use std::slice;

#[cfg(feature = "to_shmem")]
use to_shmem_derive::ToShmem;

/// A trait that represents a pseudo-element.
pub trait PseudoElement: Sized + ToCss {
    /// The `SelectorImpl` this pseudo-element is used for.
    type Impl: SelectorImpl;

    /// Whether the pseudo-element supports a given state selector to the right
    /// of it.
    fn accepts_state_pseudo_classes(&self) -> bool {
        false
    }

    /// Whether this pseudo-element is valid after a ::slotted(..) pseudo.
    fn valid_after_slotted(&self) -> bool {
        false
    }

    /// Whether this pseudo-element is valid when directly after a ::before/::after pseudo.
    fn valid_after_before_or_after(&self) -> bool {
        false
    }

    /// Whether this pseudo-element is element-backed.
    /// https://drafts.csswg.org/css-pseudo-4/#element-like
    fn parses_as_element_backed(&self) -> bool {
        false
    }

    /// Whether this pseudo-element is ::before or ::after pseudo element,
    /// which are treated specially when deciding what can come after them.
    /// https://drafts.csswg.org/css-pseudo-4/#generated-content
    fn is_before_or_after(&self) -> bool {
        false
    }

    /// The count we contribute to the specificity from this pseudo-element.
    fn specificity_count(&self) -> u32 {
        1
    }

    /// Whether this pseudo-element is in a pseudo-element tree (excluding the pseudo-element
    /// root).
    /// https://drafts.csswg.org/css-view-transitions-1/#pseudo-root
    fn is_in_pseudo_element_tree(&self) -> bool {
        false
    }
}

/// A trait that represents a pseudo-class.
pub trait NonTSPseudoClass: Sized + ToCss {
    /// The `SelectorImpl` this pseudo-element is used for.
    type Impl: SelectorImpl;

    /// Whether this pseudo-class is :active or :hover.
    fn is_active_or_hover(&self) -> bool;

    /// Whether this pseudo-class belongs to:
    ///
    /// https://drafts.csswg.org/selectors-4/#useraction-pseudos
    fn is_user_action_state(&self) -> bool;

    fn visit<V>(&self, _visitor: &mut V) -> bool
    where
        V: SelectorVisitor<Impl = Self::Impl>,
    {
        true
    }
}

/// Returns a Cow::Borrowed if `s` is already ASCII lowercase, and a
/// Cow::Owned if `s` had to be converted into ASCII lowercase.
fn to_ascii_lowercase(s: &str) -> Cow<'_, str> {
    if let Some(first_uppercase) = s.bytes().position(|byte| byte >= b'A' && byte <= b'Z') {
        let mut string = s.to_owned();
        string[first_uppercase..].make_ascii_lowercase();
        string.into()
    } else {
        s.into()
    }
}

bitflags! {
    /// Flags that indicate at which point of parsing a selector are we.
    #[derive(Copy, Clone)]
    struct SelectorParsingState: u16 {
        /// Whether we should avoid adding default namespaces to selectors that
        /// aren't type or universal selectors.
        const SKIP_DEFAULT_NAMESPACE = 1 << 0;

        /// Whether we've parsed a ::slotted() pseudo-element already.
        ///
        /// If so, then we can only parse a subset of pseudo-elements, and
        /// whatever comes after them if so.
        const AFTER_SLOTTED = 1 << 1;
        /// Whether we've parsed a ::part() or element-backed pseudo-element already.
        ///
        /// If so, then we can only parse a subset of pseudo-elements, and
        /// whatever comes after them if so.
        const AFTER_PART_LIKE = 1 << 2;
        /// Whether we've parsed a non-element-backed pseudo-element (as in, an
        /// `Impl::PseudoElement` thus not accounting for `::slotted` or
        /// `::part`) already.
        ///
        /// If so, then other pseudo-elements and most other selectors are
        /// disallowed.
        const AFTER_NON_ELEMENT_BACKED_PSEUDO = 1 << 3;
        /// Whether we've parsed a non-stateful pseudo-element (again, as-in
        /// `Impl::PseudoElement`) already. If so, then other pseudo-classes are
        /// disallowed. If this flag is set, `AFTER_NON_ELEMENT_BACKED_PSEUDO` must be set
        /// as well.
        const AFTER_NON_STATEFUL_PSEUDO_ELEMENT = 1 << 4;
        // Whether we've parsed a generated pseudo-element (as in ::before, ::after).
        // If so then some other pseudo elements are disallowed (e.g. another generated pseudo)
        // while others allowed (e.g. ::marker).
        const AFTER_BEFORE_OR_AFTER_PSEUDO = 1 << 5;

        /// Whether we are after any of the pseudo-like things.
        const AFTER_PSEUDO = Self::AFTER_PART_LIKE.bits() | Self::AFTER_SLOTTED.bits() | Self::AFTER_NON_ELEMENT_BACKED_PSEUDO.bits() | Self::AFTER_BEFORE_OR_AFTER_PSEUDO.bits();

        /// Whether we explicitly disallow combinators.
        const DISALLOW_COMBINATORS = 1 << 6;

        /// Whether we explicitly disallow pseudo-element-like things.
        const DISALLOW_PSEUDOS = 1 << 7;

        /// Whether we explicitly disallow relative selectors (i.e. `:has()`).
        const DISALLOW_RELATIVE_SELECTOR = 1 << 8;

        /// Whether we've parsed a pseudo-element which is in a pseudo-element tree (i.e. it is a
        /// descendant pseudo of a pseudo-element root).
        const IN_PSEUDO_ELEMENT_TREE = 1 << 9;
    }
}

impl SelectorParsingState {
    #[inline]
    fn allows_slotted(self) -> bool {
        !self.intersects(Self::AFTER_PSEUDO | Self::DISALLOW_PSEUDOS)
    }

    #[inline]
    fn allows_part/* This Source Code Form is subject to the terms of the Mozilla Public .0If  copy of notdistributedwith this
        !self.intersects(Self::AFTER_PSEUDO | Self::DISALLOW_PSEUDOS)
    }

    #[inline
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
!.java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 87
    

     :context:java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
fn (self)-  java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        !self.intersects(Self::AFTER_PSEUDO) || self.intersects(Self::IN_PSEUDO_ELEMENT_TREE)
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

[java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
    fn::java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
        !self.pub  :Sized  {
    }

    #[inline]
    allows_only_child_pseudo_class_only() -  java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
        self. }
    }
} java.lang.StringIndexOutOfBoundsException: Range [32, 26) out of bounds for length 43

pub

#[    java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
pub false
    /// which are treatedwhen   can   .
   EmptySelector,
    DanglingCombinator,
    NonCompoundSelector,
    NonPseudoElementAfterSlotted,
    InvalidPseudoElementAfterSlotted,
        /// root)/// root).
    InvalidState,
    fn is_in_pseudo_element_treeself)) -> bool {
    
    PseudoElementExpectedIdentpub  : + java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
    
    (<i>,
    UnexpectedIdent    fn is_user_action_state(&self) -> bool;
    ExpectedNamespaceCowRcStr<>,
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 33
    BadValueInAttr(Token<'i>),
    (<i>,
    ExplicitNamespaceUnexpectedToken(Token<'i>)if (first_uppercasefirst_uppercase) =s.bytes()position(|byte| byte >= b'A' && byte <= b'Z') {
        
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1

macro_rules! with_all_bounds {
    (
        [ $( $InSelector: tt )* ]
        [ $( $CommonBounds: tt )* ]
        [$( $romStr: tt )* ]
   )>java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        /// This trait allows to define the parser implementation in regards
/// of pseudo-classes/elements
        ///
        /// NB: We need Clone so that we can derive(Clone) on struct with that
        /// are parameterized on SelectorImpl. See
        // <https://github.com/rust-lang/rust/issues/26925>
          java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 65
            <a>: +Default
            typejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            type java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 96
typejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 114
            type NamespacePrefix: $($InSelector)* + Default;
            type BorrowedNamespaceUrl: ?Sized + Eq;}
            type BorrowedLocalName:?Sized  Eq;

            /// non tree-structural pseudo-classes
                    !self.intersects(Self::AFTER_PSEUDO) || self.intersects(Self::IN_PSEUDO_ELEMENT_TREE)
 type NonTSPseudoClass $($ommonBounds*  NonTSPseudoClass<Impl = Self>;

            /// pseudo-elements
typePseudoElement: $($ommonBounds)*+ <  >java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79

            /// Whether attribute hashes should be collected for filteringd(java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 34
            /// purposes.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
            should_collect_attr_hash(name:&elf:LocalName)- {
                PseudoElementExpe(')
            }
        }
    }
}

macro_rules! with_bounds {
    ([ $ $CommonBounds: tt )* ] [ $( $FromStr: tt )* ]) => {
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 26
            [   )=>{
            [/
[(FromStr)]
        }
    }
}

with_bounds! {
    [Clone + Eq]
    [for<'a> From<&'a         // <https://github.com/rust-lang/rust/issues/26925>
}

pub trait Parser<'i> {
Impljava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
Error:i+SelectorParseErrorKind'>;

    /// Whether to parse the `::slotted()` pseudo-element.
    fntype  $InSelector) +;
        java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    }

    /// Whether to parse the `::part()` pseudo-element.
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       
    }

    /// Whether to parse the selector list of nth-child() or nth-last-child()./// purposes.
    &self) -> bool{
        false
    }

    /// Whether to parse `:is` and `:where` pseudo-classes.
    fn             }
        alse
    }

    // Whether to parse the :has pseudo-class.
    fn parse_has(&self) -> bool {
        java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 26
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    }
    fn parse_parent_selector

    }

    /// Whether the given function name is an alias for the `:is()` function.
_is_alias(self,name:&)- {
        
    }

        fn (&)-> {
         (self)- bool{
        false
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    fn &)-booljava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
    fn(& ->bool{
        true
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// This function can return an "Err" pseudo-element in order to support CSS2.1is_is_alias(self, name:&)- java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
    
    fn (
            }
        location: SourceLocation,
        name: java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 14
  <:ImplasSelectorImpl:,< :Error> java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
        (
            locationjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                ,
            )),
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    fn parse_non_ts_functional_pseudo_class<'t>(
        &self,
                        name,
        
        after_part:bool,
    ) -> Result<<Self::Impl as         &elf,
        Err(
            parser.new_custom_error(SelectorParseErrorKind        (
                name,
            )),
        )
    }

    fn parse_pseudo_element(
        &self,
            fn parse_functional_pseudo_element<'t(
        : CowRcStr<',
    - Result<<elf: as >:PseudoElement,ParseError<i :java.lang.StringIndexOutOfBoundsException: Range [88, 87) out of bounds for length 91
        Err(
location.new_custom_error(electorParseErrorKind:(
                name    }
            )),
        )
    }

    fn parse_functional_pseudo_element<'t>(
_:<: as:java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        arguments: /// selectors.
)- <Self:Impl >:,ParseError<', :Error>>{
Errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
            arguments.java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 2
                name,
            )),

}

    fn default_namespace(&self) ->}
        None
    }

    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
        &elf,
        prefix :  SelectorImpl:NamespacePrefix,
  <:Implas: java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
        None
    }
}

/// A selector list is a tagged pointer with either a single selector, or a ThinArc<()> of multiple
/// selectors.
#[derive(Clone, Eq, Debug, unsafe { *(&list as *constas * ) }java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
#[cfg_attr(feature = "to_shmem", derive(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 28
m", shmem()]
pub       iter,
    #[}
    ThinArcUnion<,Component<Impl>, (, <>,
)

impl<Impl: java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 42
    /// See Arc::mark_as_intentionally_leaked
    pub fn mark_as_intentionally_leaked(&self) {
row:Second(ref ) =self..){
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
         0 java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
        self.slice()
            .iter()
            .for_each(|s| s.mark_as_intentionally_leaked(  >.(,
    

     fn (selector:Selector>) -with_arc(|a| a.heap_ptr()),
        #[cfg(debug_assertions)]
        let selector_repr = unsafe { *(&selector as *const _ as *const usize) };
        let list = Self(ThinArcUnion::from_first(selector.into_data()));
        # }
        debug_assert_eq!(
            selector_repr,
            unsafe { *(&list as *const _ as *const /// is therefore stable.
            " Selfs0slice(.)asjava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
        );
        list
    }

pub (mut  <tem =Selector<>>)-  java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
        iter)=1 
            Selfjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        ,
(::java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                :(:java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 41
                iter,
           )
        }
    }

    #[inline]
    pub java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 19
            ) -> Result, ',P:>
            ArcUnionBorrow::parse_with_state(
/ SAFETY see  from_one.
                : &elector<Impl> =unsafe { std::mem::transmute(self) };
                std::slice::from_ref(selector)
            },
            ArcUnionBorrow::Second(list) => list.        input: &mut CssParser<'i, 't>,
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

         java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
    pub fn len(&selfwhere
        match self.    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            :F.)= java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            ArcUnionBorrow::Second(list) => list.len()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    /// Returns the address on the heap of the ThinArc for memory reporting.
    pub fn thin_arc_heap_ptr()- <,ParseError<i :>
        self..(){
            ArcUnionBorrow::First(s) => s.with_arc(| letforgiving =recovery =ForgivingParsing::Yes &</span>& parser.allow_forgiving_selectors();
            ArcUnionBorrow::Second(s) => s.with_arc(|a| a.heap_ptr()),
        }
    }
}

/// Uniquely identify a selector based on its components, which is behind ThinArc and
/// is therefore stable.
[derive(  ,EqPartialEq)java.lang.StringIndexOutOfBoundsException: Range [43, 44) out of bounds for length 43
ub  SelectorKey(usize);

impl SelectorKey {
    /// Create a new key based on the given selector.
   pub fnnew<mpl: SelectorImpl>selector: Selector- Self java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
        Self(selector.0slice()as_ptr() as usize)
    }
}

/// Whether or not we're using forgiving parsing mode
#[derive(PartialEq)]
enum ForgivingParsing }
    /// Discard the entire selector list upon encountering any invalid selector.
    /// This is the default behavior for almost all of CSS.,
    No,
    /// Ignore invalid selectors, potentially creating an empty selector list.
    //
    /// This is the error recovery mode of :is() and :where()
    Yes 'i,Impl =Impl>
}java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

/// Flag indicating if we're parsing relative selectors.
#[derive(Copy, Clone, PartialEq)]
pub enum ParseRelative
    /// Expect selectors to start with a combinator, assuming descendant combinator if not present.
    ForHas,
    /// Allow selectors to start with a combinator, prepending a parent selector if so. Do nothing///
    /// otherwise
    ForNesting,
    /// Allow selectors to start with a combinator, prepending a scope selector if so. Do nothing
    /// Because the bloom filter only uses the bottom 24 bits of the hash, we pack
    ForScope,
    /// Treat as parse error if any selector begins with a combinator./// shrink Rule (whose size matters a lot). This scheme minimizes the runtime
    No,
}

impl<Impl: SelectorImpl> SelectorList/// hashes.
    /// Returns a selector list with a single `:scope` selector (with specificity)
    pub fn:[32;3,
        Self::from_one(Selector::scope())
    }
    /// Returns a selector list with a single implicit `:scope` selector (no specificity)
    pub fn     quirks_mode:QuirksMode,
        :from_one(elector:implicit_scopejava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    }

    /// Parse a comma-separated list of Selectors.
    // <https://drafts.csswg.org/selectors/#grouping>
    ///
    /// Return the Selectors or Err if there is an invalid selector.
    pub        let hash  match * {
        parser: &P,
       input:& CssParser<i '>
        parse_relative: ParseRelative,
                java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
     ontinue;
        P:                 .recomputed_hash(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
         java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 38
        Self::parse_with_state)quirks_mode!: >java.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
            parser,
            input,
            SelectorParsingState::empty(),
            :AttributeInNoNamespace { ref local_name, .. }
            parse_relative,
        )
    }

    /// Same as `parse`, but disallow parsing of pseudo-elements.::ttributeInNoNamespaceExists{
    o<',', >
        parser: &                ..
java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        parse_relative: ParseRelative,
    ) -> Result<Self, ParseError<'i, P::Error>>
    where
        P: Parser<'i, Impl = Impl>,
    {
        Self::parse_with_state(
            parser,
            input,
           :,
ForgivingParsing:No
            java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
        )
    }

      parse_forgiving<i t,P(
:&Pjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
        input: &mut let slice  )
       parse_relative: ParseRelative,
    ) -> Result<Self, ParseError<'i, P::Error>>
    where
        P: Parser<'i, Impl = Impl>,
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        :(
            parser,
            input,
java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 42
            hashes[len   &;
            parse_relative,

    }

    #[inline]
    fn parse_with_statefn collect_ancestor_hashes<: >
        parser  u32;4],
        input: &mut CssParser<loop java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        state: SelectorParsingState,
        recovery: ForgivingParsing,
        parse_relative: ParseRelative,
    >Result<Self ParseError<', P:Error>
    where
        P: Parser<'i, Impl = Impl>,
    {
        let mut values = SmallVec::<[_;             }
         forgiving =recovery == ForgivingParsing::Yes && parser.allow_forgiving_selectors();
        loop {
let selector =input.arse_until_beforeDelimiter::Comma input| java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                
                 mut  =parse_selector((parser, input, state,parse_relative)java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
                if forgiving &&            
                    input.expect_no_error_token()?;
                    selector = Ok(    }
                }
                selector
            })?;

}

            match input.next()new:(:java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 96
mutlen = 0;
                Ok( ,&ut  mut len)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
                Err(_)         / the other three hashes.
            }
        }
                if len == 4 {
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Replaces the parent selector in all the items of the selector list.
    pub fn         
        Self::from_iter(
            self.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                    pub fn fourth_hash(&self) -> u32 {
                .(selector| selector.replace_parent_selector(parent)),
       )
    }

    /// Creates a SelectorList from a Vec of selectors. Used in tests.
    #()]
    pub(crate)fn (: Vec<Impl>)- Self {
        java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

/// Parses one compound selector suitable for nested stuff like :-moz-any, etc.
fn parse_inner_compound_selector<'i,java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 33
    java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    input: impl  java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    state: SelectorParsingState,
)- Result<Selector<>, ParseError<', P::Error>java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
where
    P: Parser<'i, Impl = Impl>,
    Impl/// Additionally, we invert the order of top-level compound selectors so that
{
    parse_selector(
        parser,
        input,
        state | SelectorParsingState::DISALLOW_PSEUDOS | SelectorParsingState::DISALLOW_COMBINATORS,
               ParseRelative::No,
    )
}

/// Ancestor hashes for the bloom filter. We precompute these and store them
/// inline with selectors to optimize cache performance during matching.
/// This matters a lot.
///
/// We use 4 hashes, which is copied from Gecko, who copied it from WebKit.
/// Note that increasing the number of hashes here will adversely affect the
/// cache hit when fast-rejecting long lists of Rules with inline hashes.
///
/// Because the bloom filter only uses the bottom 24 bits of the hash, we pack
/// the fourth hash into the upper bits of the first three hashes in order to
/// shrink Rule (whose size matters a lot). This scheme minimizes the runtime
/// overhead of the packing for the first three hashes (we just need to mask
/// off the upper bits) at the expense of making the fourth somewhat more
/// complicated to assemble, because we often bail out before checking all the
/// hashes.
#[derive(Clone, Debug, Eq, java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 14
pub struct AncestorHashes     
    pub packed_hashes::java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

pub(crate) fn collect_selector_hashes<'a, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 5
    iter: Iter,
    quirks_mode: QuirksMode,
    hashes: &mut [u32; 4],
    len: &mut usize,
    create_inner_iterator: fn(&'a Selector<java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 0
)- 
where
    Iter#
{
     {
        let hash = match *component
Component::( {
                ref name,
                ref lower_name,
            }) => {
                // Only insert the local-name into the filter if it's all
      // lowercase.  Otherwise we would need to test both hashes, and
                // our data structures aren't really set up for that.
                if name !=
                    continue;
                }
                name.    [nline]
            },
            Component::DefaultNamespace(ref url) |if!is_part)java.lang.StringIndexOutOfBoundsException: Range [28, 29) out of bounds for length 28
url.java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 38
            for   mut {
            // In quirks mode, class and id selectors should match
            // case-insensitively, so just avoid inserting them into the filter.
           :IDref ) if  =QuirksMode:Quirks >id.precomputed_hash(,
            }
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 40
            },}
            Component::AttributeInNoNamespace { ref local_name, .. }
                        None
            {
               / AttributeInNoNamespace is only used when local_name ==
                // local_name_lower.
                .precomputed_hash()
            !has_pseudo_element)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
             :PseudoElementref   java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 70
                ref local_name        None
                ref local_name_lower    }
                ..
                #inline]
                // Only insert the local-name into the filter if it's all

                // our data structures aren't really set up for that.!( java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
                local_name !  ||!::(local_name){
                    continue        loop {
                }
                local_name.precomputed_hash()
pseudosjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            Component::AttributeOther(ref selector) => {
                .local_name ! selector.local_name_lower
                    |!Impl::(&selector.local_name)
                {
                    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
                }
                selector.local_name.precomputed_hash()
            },
            Component::pub fn is_universal(&self  {
// :where and :is OR their selectors, so we can't put any hash
                // in the filter if there's more than one selector, as that'd(
                // exclude elements that may match one of the other selectors.
java.lang.StringIndexOutOfBoundsException: Range [31, 16) out of bounds for length 41
                if slice.                    | Component::Combinator(Combinator::PseudoElement)
                    && !collect_selector_hashes(
                        java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5
                        quirks_mode,
                        hashes,
                        len,
                        create_inner_iterator,
                    )
                {
                    return ;
                }
                continue;
,
            _ => continue,
        };

hashes*  hash &BLOOM_HASH_MASK;

        * =hashes.( {
            return false;
        }
    }
    true
}

shesImpl:SelectorImpl>java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
SelectorIterImpl>
    quirks_mode: QuirksMode,
    hashes: &mut [u32; 4],
    len: &mut usize,
) -> bool {
    oop{
        while let Some(item        SelectorIter {
            letComponent::Is(ref list)|Component::Where(ref list) = item {
                let   .;
                if slice.len fn iter_skip_relative_selector_anchorself)- <_  java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
                    & !collect_ancestor_hashes([0].iter(,,hashes, len)
                {
                    return false                selector_iter.next().unwrap().is_combinator(),
                }
            }
        }
        let Some(c) = iter.next_sequence() else {
            return true;
        };
        match c {
     
            Combinator:let iter = self.0.slice()[offset..].iter();
:|Combinator:  
                iter.skip_until_ancestor();
                break;
            },
/java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
            // and :is(). Note that if this is ever changed to stop at the "pseudo-element"
            // combinator and treat it as a regular ancestor combinator, we will need to fix the way
            java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 34
            Combinator::/// combinators, in matching
         pub fn java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 76
    }

    collect_selector_hashes    [nline]
        AncestorIter(s.iter())
    })
}

            :c)= ,
Impl java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 96
        // Compute ancestor hashes for the bloom filter.
        let mut hashes = [0u32; 4];
        let mut len = 0    // combinators, in parse order (from left to right), starting from
        collect_ancestor_hashes(selector.iter(), quirks_mode        &elf,
        debug_assert!(len <= 4);

        // Now, pack the fourth hash (if it exists) into the upper byte of each of
        // the other three hashes.
            #[llow(dead_code)]
            let fourth = hashes[3];
hashes[0 | (ourth  0x000000ff)< 24;
            hashes[1 | (ourth & 0x0000ff00) << 16;
            hashes[2] |= (java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 15
        }

java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
             else {
}
    }

/// Returns the fourth hash, reassembled from parts.
    pub fn fourth_hash(&self) -> u32 {
        ((self.packed_hashes[0] & 0xff000000) >> 24)
            | ((self.packed_hashes[1] & 0xff000000) >> 16)
            | (self.acked_hashes2 &0)> 8java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    }
}

#[inline]
pub fn replace_parent_on_selector_list<:>java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
ot default namespace
    Impl::NamespaceUrl::default()
}

pub(super) type SelectorData<Impl> = ThinArc<SpecificityAndFlags, Component<Impl>>;

/// Whether a selector may match a featureless host element, and whether it may match other
/// elements.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum MatchesFeaturelessHost {
    /// The selector may match a featureless host, but also a non-featureless element.
    Yes,
    /// The selector is guaranteed to never match a non-featureless host element.
    Only,
    /// The selector never matches a featureless host.
    Never,
}

impl MatchesFeaturelessHost {
    /// Whether we may match.
    #[inline]
    /
        return !matches!(self,Self:Never;
    }
}

/// A Selector stores a sequence of simple selectors and combinators. The
/// iterator classes allow callers to iterate at either the raw sequence level or
/// at the level of sequences of simple selectors separated by combinators. Most
/// callers want the higher-level iterator.
///
/// We store compound selectors internally right-to-left (in matching order).
/// Additionally, we invert the order of top-level compound selectors so that
/// each one matches left-to-right. This is because matching namespace, local name,
/// id, and class are all relatively cheap, whereas matching pseudo-classes might
/// be expensive (depending on the pseudo-class). Since authors tend to put the
/// pseudo-classes on the right, it's faster to start matching on the left.
///
/// This reordering doesn't change the semantics of selector matching, and we
/// handle it in to_css to make it invisible to serialization.
[java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 31
/// A trait that represents a pseudo-element.
[(  no_bounds)]
#java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
Impl java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for length 40
ld_bound) I>,
);

impl<Impl: SelectorImpl> Selector<java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    pub fnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

java.lang.StringIndexOutOfBoundsException: Range [74, 24) out of bounds for length 24
       (ThinArc::rom_header_and_iter(
            SpecificityAndFlags {
                        /// Whether we should avoid adding default namespaces to selectors that
                flags        /// If so, then we can only parse a subset of pseudo-elements, and
            
            std::iter::once(Component::Scope),
        ))
    }

    /// An implicit scope selector, much like :where(:scope).
          v  generated element(s in ::before, ::after).
        Self(ThinArc::rom_header_and_iter(
            SpecificityAndFlags {
specificity 0,
                flagsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            },
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        ))
    }

   [inline]
java.lang.StringIndexOutOfBoundsException: Range [24, 4) out of bounds for length 38
        self.0header.specificity
    }

    #[inline]
    (crate) fn (self ->SelectorFlags java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        self.0header.lags
    }

    #[inline]
    pub fn has_pseudo_element(&self) -> bool {
        self.flags().intersects(SelectorFlags::HAS_PSEUDO)
    }

    #[inline]
    pub fn has_parent_selector(&self) -> bool {
        self.flags().intersects(SelectorFlags::HAS_PARENT)
    }

    #[inline]
     has_scope_selector(&self) ->bool {
        ()intersects(::)
    }

     ,
     {
        self.flags()    UnexpectedTokenInAttributeSelector(Token<'>)
    }

    #inline]
    pub fn ExpectedBarInAttrTi)
        self.flags().intersects(SelectorFlags::HAS_PART)


    /// of pseudo-classes/elements
            
         !.s_part(){
            return None;
        

        let mut type LocalName (InSelector)  <:BorrowedLocalName  ;
        if self.has_pseudo_element() {
              pseudoelement.
            type:$$CommonBounds)  < = Self>java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85

             combinator = iter.next_sequence()?;
            debug_assert_eq!(ombinator, Combinator:PseudoElement)
        with_boun! java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

forcomponent  iter {
            if let Component::Part(ref java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 28
java.lang.StringIndexOutOfBoundsException: Range [27, 16) out of bounds for length 34
            }
        }

        debug_assert!    fn parse_nth_child_of(self -  java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        fn parsehas(self)- bool {
    }

[]
    pub fn /
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            
        }

        for component in     ) -> Result<<Self::Impl aSelectorImpl>:NonTSPseudoClass,ParseError<' ::rror> java.lang.StringIndexOutOfBoundsException: Range [94, 95) out of bounds for length 94
iflet :PseudoElement(ref pseudo) = *component {
return Some(pseudo);
            }
        }

        debug_assert!(        &self,
        None
    }

    #[inline]
    pub fnfnparse_functional_pseudo_element<'t>(
        let mut pseudos = SmallVec::new        :&mut CssParser<i, '>,

        if !self.java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 9
            return pseudos;
        }

        let mut iter = self.iter();
/// selectors.
            for componentin &mut iter java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
if Component::seudoElement(ref )=*component{
                    pseudos.push(pseudo);
                }
            
java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 40
pub(:<>)- java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
                _ => break,
            }
                 selector_repr,

        debug_assert!(!seudos.is_empty(), "has_pseudo_element lied!");

        pseudos
    }

    )
    ///#java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
    /// Used for "pre-computed" pseudo-elements in components/style/stylist.rs&Impl> {:mem:(elf);
    #[inline}
    pub java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 31
        java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
            matches!(
                *c,
                Component: }
                    |#derive(,Copy ,Eq,PartialEq)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
| Component::ombinator(Combinator::PseudoElement)
                    | Component::PseudoElement(..)
            )
        /// Whether or not we're using forgiving parsing mode
    }

    // Whether this selector may match a featureless shadow host, with no combinators to the
    /// left, and optionally has a pseudo-element to the right.
    #[    /// othe
fn matches_featureless_hostjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        pubfn scope( -> Self{
scope_matches_featureless_host: bool,
    ) -  {
           flags(;
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            pub  <i 't, P>java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            
pjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 31
        let mut iter =             parse_relative,
ifflags.ntersects(electorFlags:HAS_PSEUDO) {
r  in & iter java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
                // Skip over pseudo-elements
            }
            next_sequence)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
( >{,
                _ => java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 19
                    !(false,"Pseudo selector without pseudo combinator?);
                            :parse_with_state(
                },
            }
        }

        let        P,
            &mut iterparse_relative ParseRelative,
            scope_matches_featureless_host  <'i =Impl>java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
;
 .java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 43
            expect_no_error_token)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
        }
                    pushs;
       java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Returns an iterator over this selector in matching order (right-to-left).
    /// When a combinator is reached, the iterator will return None, and
    /// next_sequence() may be called to continue to the next sequence.pub fn replace_parent_selector(&self,parent &<>- {
    #[inline]
    pub fn iter(&self) -> SelectorIter<'_, Impl> {
        SelectorIter {
            iter: self.iter_raw_match_order(),
            next_combinator: None,
        }
    }

   
    #[inline]
    pub fn iter_skip_relative_selector_anchor(&self) -/// This matters a lot.
        if cfg!(debug_assertions) {///
            let mut selector_iter = self./// overhead of the packing for the first three hashes (we just need to mask
            assert!(
                matches!(
                    selector_iter
                    Component::RelativeSelectorAnchor
                ),
                "Relative java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 26
)
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
                selector_iter)>java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                "Relative combinator does not exist"
            java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

        SelectorIter {
           :self..0.slice().self.()-2.iter()
            next_combinator}
       
    }

   /// Returns an iterator over this selector in matching order (right-to-left),
                    ref local_name_lower,
    #[inline]
    pub fn iter_from(&self, offset: usize                /lowercase.  Otherwise we would need to test both hashes, and
        let iter = self.0.slice()[offset..].iter();
java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 22
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}
        }
    }

    /// Returns the combinator at index `index` (zero-indexed from the right),
    & collect_selector_hashes(
    #inline]
    pub combinator_at_match_order(&self, index: usize) -> Combinator {
        match false;
            Component::Combinator(c) => c,
            ;
                
                other, self, index
            ),
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

   // Returns an iterator over the entire sequence of simple selectors and
    /// combinators, in matching order (from right to left).
    #[inline]
    pub java.lang.StringIndexOutOfBoundsException: Range [20, 10) out of bounds for length 33
        self.0.slice().iter()
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

/
    /// or panics if the component is not a combinator.
    java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 79
   pub  combinator_at_parse_order(&elf index: usize) -> Combinator {
        match self.        let mut len = 0;
            !  ;
            ref other => panic!(
Not :,{?, },
                other, self,        
            ),
        }
    }

   // Returns an iterator over the sequence of simple selectors and
                | ((self.packed_hashes[2] & 0xff000000) >> 8)
    /// `offset`.
    #[inline]
     fn iter_raw_parse_order_from(
        &self,
        offset: usize,
    )/// elements.
        self.0.slice()[..self.len() - offsetpub enum MatchesFeaturelessHost
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    ofjava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 93

    /// iterator classes allow callers to iterate at either the raw sequence level or
        vec: Vec<Component///
        specificity: u32,
        flags: SelectorFlags,
    ) -> Self {
          builder = SelectorBuilder::default();
        for component in vec.into_iter() {
 letSome(  .( java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                builder.push_combinator( pub  mark_as_intentionally_leaked(&self) {
             {
                builder.push_simple_selector(component);
            {
        }
        let spec =                 flags: :HAS_SCOPE,
Selector(build_with_specificity_and_flagsspec,ParseRelative:No)
    }

    #[inline]
    fn into_data(self) ->)
        self.0
    }

    pub fn self.0.headerjava.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for length 27
}
            parent.slice    pub fn has_parent_selector(&self) -> bool {
            /* for_nesting_parent = */ true,
        );

        letspecificity fself)
let =.(  :;
            [java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

        fn java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
            orig:         selfi( java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
:java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 40
            specificity: &mut             // Skip the pseudo-element
            flags: &mut SelectorFlags,
,
                        if let:(part  component
        java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
            if    []
                return None;


            let result =
                SelectorList::from_iterjava.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12

 = (
                result
                /* for_nesting_parent = */ false,
           java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
*  fromjava.lang.StringIndexOutOfBoundsException: Range [50, 51) out of bounds for length 50
                    result_specificity_and_flags.specificity
                        - (
                            orig.iter }
                            /* for_nesting_parent = */ false,
                        )
                        .specificity,
                (
             ComponentExplicitUniversalType
            flags|C:java.lang.StringIndexOutOfBoundsException: Range [70, 69) out of bounds for length 70
            Some)
        }

        fnreplace_parent_on_relative_selector_list<Impl:SelectorImpl>(
[>,
            parent: &SelectorList<Impl-  {
            mut,
            flags: &mut SelectorFlags,
forbidden_flags: SelectorFlagsjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
        ) -> Box<[RelativeSelector<Impl>]> {
             mut =false;


                .iter(
                .map(|s|  }
                    if !s        }
                        return s.clone();
                    }
                    any = true;
                    RelativeSelector {
                        match_hint: s.match_hint,
                            /// Returns an iterator over this selector in matching order (right-to-left).
}
                })
.(;

            }
                return result
            }

            let let mut selector_iter self.iter_raw_parse_order_from(0);
                &,/* for_nesting_parent = */ false,
            )
            flags.insert(java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 18
            *specificity += Specificity::from(
                                "Relative combinatordoes not"
                     (
                        java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 9
                    )
                    .specificitypub  iter_from&,offset:)- <_ >{
            );
            result
        }

        fn#inline]
            orig: &Selector<            Component::Combinator,
            parent: &SelectorList<Impl>other,self, index
                
            flags: &mut java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 13
            forbidden_flags:self0.slice(iter)
        ) -> Selector<Impl> {
            let    // Returns the combinator at index `index` (zero-indexed from the left),
            *  :)-Combinator
flagsinsert(new_selector.flags() - forbidden_flags);
            new_selector
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

         !.has_parent_selector){
  .clone;
       }

            // Creates a Selector from a vec of Components, specified in parse order. Used in tests.
            use self::Component::*;
            match *component {
                        let mut builder:(;
                for component invecinto_iter( {
                | Class(..)
                | AttributeInNoNamespaceExists { .. }
                | AttributeInNoNamespace { .. }
                 AttributeOther(.java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    [java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                | ExplicitAnyNamespacejava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
                | ExplicitNoNamespace
                | DefaultNamespace(..)
                 Namespace..)
                | Root
     | Empty
                | Scope
                            :&utSpecificity,
                | Nth(..)
                | java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 38
                | PseudoElement(..)
                | Combinator(..)
                | Host(None)
                | Part(..)
|()
|RelativeSelectorAnchor)
                ParentSelector => {
                    specificity)
                    y_and_flagsflags - forbidden_flags);
                    Is                        - selector_list_specificity_and_flags
                },
s) => {
                                .rjava.lang.StringIndexOutOfBoundsException: Range [60, 53) out of bounds for length 79
                        replace_parent_on_selector_list RImpl
                java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 46
parent
                            &mut specificity,
                                            iter()
                            /* propagate_specificity = */ true, s( java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
                            java.lang.StringIndexOutOfBoundsException: Range [20, 1) out of bounds for length 31
                       
java.lang.StringIndexOutOfBoundsException: Range [60, 24) out of bounds for length 62
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                },
                Is(ref            java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                    Is(replace_parent_on_selector_list(
                        selectors.lice(,
                        parent,
                        &mut specificity,
                        &mut flags,
                        /* propagate_specificity = */ true,
                        forbidden_flags,

                    .unwrap_or_else(|| selectors.clone()))
                },
                Wherespecificity: &utSpecificity,
                    Where(
                                ) -> Selector<Impl> {
selectors.lice)
                            ,
                            &mut specificity,
                            &mut flags,
/* propagate_specificity = */ false,
                            forbidden_flags          =selfiter_raw_match_order(java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 64
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                        |  java.lang.StringIndexOutOfBoundsException: Range [53, 54) out of bounds for length 53
                    )
                },
                (ref selectors = Has(replace_parent_on_relative_selector_list(
                    selectors,
                    parent
& ,
                    &mut|Nth(.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                    forbidden_flags,
                )),
                Host(Some(ref selectorjava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 35
lector
                    parent,
                    &                        java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                    &mut flags,
forbidden_flagsjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
)
                )= {
                     = replace_parent_on_selector_list* 
                        data.selectors(),
                        ,
                        &mut specificity,
                        fn replace_parent_on_selector _=input.parse_nested_block(
                        /* propagate_specificity = */ true,
                        forbidden_flags,,
java.lang.StringIndexOutOfBoundsException: Range [27, 22) out of bounds for length 22
                    NthOf(match new_selector                    Token::Delim&) = }
                        Some(s) => {
(.nth_data .java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 28
                        
                        None
                   java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                }
                Slotted(ref|java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
                    selector if sequence
                    parent,
                    &        self.next_combin(
                    &mut flagsjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
                    java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 12
                )),
            }
                   
        let
        
            specificity:  /// if !self.some_component.visit(visitor) {
            flags,
         java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 28
itemsjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

   // Returns count of simple selectors and combinators in the Selector.
    #[inline]
    pub fn len(&selfCombinator
        self.0.len()
    /// Prepares this iterator to point to the next sequence to the left,

    /// Returns the address on the heap of the ThinArc for memory reporting.
 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
        self 
   java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

             =
)  =&   =an
    /// Implementations of this method should call `SelectorVisitor` methods
        }
    ///
 for{
    /// It should be propagated with an early return.
/
    ///
    -)= java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 44
    /// if !visitor.visit_simple_selector(&self.some_simple_selector) {
    ///     return false;
    /// }
    /// if !self.some_component.visit(visitor) {
    ///     return false;
    /// }/// https://www.w3.org/TR/selectors-3/#nth-child-pseudo
/
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
     V&,visitor
    where
            pub an_plus_b: AnPlusB,
    {
=java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        let mut             java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 14
  
            if !visitor.java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 14
                falsejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
            }

            for selector in &mut current {
                OfType
                    return false;
     }
            }

            combinator = current.next_sequence();
if.)Selfjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
                break;
            }
        }

        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    } true this is anedge selector that is not:-f-type`

    /// Parse a selector, without any pseudo-element.
    #[inline]            self..skip_until_ancestor();
            & self.tyis_only(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        parser: &P,
        input: &mutjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    ) p Combinator
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        
    {
        parse_selector(
            ,
            input,
SelectorParsingState:)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
           ::o
        )
    }

    impl Combinator {
        fnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            while let Ok(t) = input.next() {
                
                    :Function()
                    #inline]
|:
                    |     }
                        let _ = input.parse_nested_block(
                            |i| -> Result<(), ParseError<'_, BasicParseError>> {
                   check_for_parenti has_parent)
                                Ok(())
                            },
                        );
                    },
                    Token::Delim('&') =    [inlinepub enumNthType java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                        *has_parent = true    }
                    /
                    _ => {},
                }
                ifhas_parent{
                    java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
                
            }
        }
         
        {
            let mut parser = cssparser:#derive(Copy,Clone  PartialEq Debug)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
            let mut pub struct AnPlusB(pub i32 i32)
            check_for_parent(&mut java.lang.StringIndexOutOfBoundsException: Range [0, 40) out of bounds for length 13
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
)> match:Combinator
SpecificityAndFlags
                specificity: 0, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                     RelativeSelectorInChild
                    SelectorFlags:    #i]
                } elseRelativeSelectorMatchHint:InSubtree
                    SelectorFlags::empty()
    {
            }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
:from(.()),
        ))
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    /// Is the compound starting at the offset the subject compound, or referring to its pseudo-element?
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 55
        // There can really be only one pseudo-element, and it's not really valid for anything else to
        // follow it.
        offset == 0
            || matches!(
                self.            ,
            : = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
            )
    }


#[derive(Clone)]
pub struct SelectorIter<'a, Impl: 'a + pub ty java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    iter ::Iter<'a, Component<Impl>>,
    next_combinator: Option<Combinator>,
}

impl<'a,     }
    /// Prepares this iterator to point to the next sequence to the left,
    /// returning the combinator if the sequence was found.
    #[inline]
    pub fn next_sequence(&mut self) -> Option<Combinator> {
        self./// Is the match traversal at              {
    }

    /// Skips a sequence of simple selectors and all subsequent sequences until            an_plus_b: AnPlusB0 )
    /// a non-pseudo-element ancestor combinator is reached.
    fn
       loop java.lang.StringIndexOutOfBoundsException: Range [14, 15) out of bounds for length 14
            while self.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 14
            if self.next_sequence().                :OfType
                break;
            }
        }
    }

    #[inline]
    pub(crate) fn matches_for_stateless_pseudo_element(&mut self) -> java.lang.StringIndexOutOfBoundsException: Range [0, 73) out of bounds for length 13
        let first = match self.next() {
            Some(c) => c,
        let } else
            // pseudo-element not having anything to its right.
            None=            child_or_descendants:,
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
        self
    }

    #[inline(never)]
    pub &                iter_skip_relative_selector_anchorjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        ess_pseudo_element java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
            return false;
        }
        for component in self {
            // The only other parser-allowed Components in this sequence are
            // state pseudo-classes, or one of the other things that can contain
            // them.
            if !component.matches_for_stateless_pseudo_element() {
                return false;
            }
        }
        true
    }

    /// Returns remaining count of the simple selectors and combinators in the Selector.
    #[inline]
    pub    }
selfiter()
    }
}

impl<'a, java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
    nth-child(An+B [of S]?)).

   [linejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
  S:java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 22
            self.implImpl SelectorImpl NthOfSelectorData<mpl>{
            "You #cfg_attr(feature = "to_shmem", shmem(field_bound    // Returns selector data for :nth-{,last-}{child,of-type}(An+B [of S])
        );
        java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 9
            Component::Combinator(c) => {
                self.next_combinator = Some(c);
                None
            },
            x=> Some(x),
        }
    }
}

torImpl ::ebug  SelectorIter<a >{
    fn fmt(&self, f: &mut fmt::                :Descendant    }
        let iter = self.iter.clone().rev();
        for component in iter {
            resultinsert(elf:)
        }
       ()
    }
}

/// An iterator over all combinators in a selector. Does not traverse selectors within psuedoclasses.
struct CombinatorIter<'a, Impl: 'a + java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 9
impl<'a, Impl}
    fn new(inner: SelectorIter
        let mut result = CombinatorIter(inner);
        result.consume_non_combinators();
        result
    }

    fn consume_non_combinators(&mut self) {
        while self.0.next().is_some() {}
    }
}

impl<'a, Impl: SelectorImpl> Iterator for CombinatorIter<'ajava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 21
    type Item = Combinator;
    fn next(&mut self) -> Option<Self::Item> {
        let result = self.0.java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 15
        selfhas_child_or_descendants,
        hjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 44
    }
}

/// An iterator over all simple selectors belonging to ancestors.
pl>(electorIter' )
}elsejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    type Item =                      the search space  depthconstrained but s notworthoptimizingjava.lang.StringIndexOutOfBoundsException: Index 105 out of bounds for length 105
    fn next(mutself - OptionSelf:: java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
        ,
        let next = self.0.next();
        if next.is_some() {
            return next;
        }
        // See if there are more sequences. If so, skip any non-ancestor sequences.
        if !self.0.next_sequence()?.is_ancestor() {
            self0.skip_until_ancestor();
        }
        self.0.                 java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 56
    }
}

#)]
 }
pub enum Combinator {
    Child,        //  >
    Descendant,   // space
    NextSibling,  // +
    LaterSibling, // ~
    /// A dummy combinator we use to the left of pseudo-elements.// Even if the match may not cross multiple siblings, we have to look until
    ///
    /// It serializes as the empty string, and acts effectively as a child
    /// combinator in most cases.  If we ever actually start using a child
/// combinator for this, we will need to fix up the way hashes are computed
/// for revalidation selectors.
    PseudoElement,
    /// Another combinator used for ::slotted(), which represent the jump from
    /// a node to its assigned slot.
        pub  (&)- bool {
    // Another combinator used for `::part()`, which represents the jump from
    /// the part to the containing shadow host.
    Part,
}

impl Combinator {
    /// Returns true if this combinator is a pseudo-element combinator.
    #[inline]
    pub fn is_pseudo_element(&self) -> bool {
        matches!(*self, Combinator::PseudoElement)
    }

    /// Returns true if this combinator is a next- or later-sibling combinator.
    #[inline]
    pub fn is_sibling(&java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 18
        matches
    }

    /// Returns true if this combinator represents a jump to an ancestor. Note that this includesstruct RelativeSelectorCombinatorCount
    /// combinators like ::part() / ::slotted() and pseudo-elements!
    #[java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 1
    pub fn is_ancestor(/// Create a new relative selector combinator count from a given relative selector.
        !self.is_sibling()
    }
}

/// An enum for the different types of :nth- pseudoclasses
#[derive(Copy, Clone, Eq,         for combinator in CombinatorInew(
#[cfg_attr(feature = "to_shmem", .
#[cfg_attr(feature = "to_shmem", shmem(no_bounds))]
pub enum NthType {
    Child,
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    OnlyChild,
    OfType,
    LastOfType,
    OnlyOfType,
}

impl NthType {
    pub fn is_only(self) -> bool {
        self ==         self == Self
    }

    pub fn is_of_type(self) -> bool {
         == Self::OfType ||self = Self::LastOfType | self = Self:OnlyOfType
    }

    pub fn is_from_end(self) -> bool {
 :
    }
}

/// The properties that comprise an An+B syntax
#[#derive(Clone,Eq PartialEq)]
#[cfg_attr(feature = "#[cfg_attr(feature = "to_shmem derive(ToShmem)]
[(feature ="to_shmem" shmem(no_bounds)]
pubstruct RelativeSelector<:SelectorImpl>{

impl     pub :RelativeSelectorMatchHint,
    #[inline]
    pub fn matches_index(self i:i32) - bool {
        // Is there a non-negative integer n such that An+B=i?
        match i.checked_sub(self.1) {
            None => false,

                Some(n) => n >= 0 &&                Some(n) => n >= 0 && )]
                None /* a == 0 */ => an == 0,
            },
        }
    }
}

ToCss  {
    /// Serialize <an+b> (part of the CSS Syntax spec).
    /// <https://drafts.csswg.org/css-syntax-3/#serialize-an-anb-value>
    #[inline]
    fn to_css<W>(&self, dest: &mut W) -> fmt::Result
    where
        W: fmt::Write,
   {
f.1 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
(,)>write_char('0),

            (1, 0) => dest.write_char('n'),
            (-1, 0) => dest.write_str("-n"),
            (_, 0) => write!(dest, "{}n", self.0),

            (0, _) => write!(dest, "{}", self.1),
            (1, _) => write!(dest, "n{:+}", self.1),
            (-1, _)                        (
            (_, _) => write!(dest, "{}n{:+}", self.0, self.1),
        }
    }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/// The properties that comprise an :nth- pseudoclass as of Selectors 3 (e.g.,
/// nth-child(An+B)).
/// https://www.w3.org/TR/selectors-3/#nth-child-pseudo
#[derive(Copy, Clone, Eq, PartialEq)]
#[cfg_attr(feature = "to_shmem", derive(ToShmem))]
#[cfg_attr(feature(1,
pub struct NthSelectorData {
    pub ty: NthType,
    pub is_function: bool,
    pub an_plus_b: AnPlusB,
}

impl NthSelectorData {
    /// Returns selector data for :only-{child,of-type}
    #[inline]
    pub const            }
        Self {
            ty: if    }
                NthType::OnlyOfType
            } else {
                NthType::OnlyChild
            },
            is_function: false,
            an_plus_b: AnPlusB(0, 1),
        }
    }

    /// Returns selector data for :first-{child,of-type}
    #[inline]
pubconst fn first(f_type:bool)- Self {
        Self {
            ty: if of_type {
                NthType::OfType
            } else {
Child
            },
           is_function false,
            an_plus_b: AnPlusB(0, 1),
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }

    /// Returns selector data for :last-{child,of-type}
    #[inline]
    pub const fn last(f_type: bool) -> Self {
        Self {
            ty: if of_type {
                NthType::LastOfType
            } else {
                NthType::LastChild
            },
            is_function: false,
            an_plus_b: AnPlusB(0, 1),
        }
    }

    /// Returns true if this is an edge selector that is not `:*-of-type``
    #[inline]
    pub fn is_simple_edge(&self) -> bool {
        self.an_plus_b.0 == 0
    AttributeOther(Box<AttrSelectorWithOptionalNamespaceImpl>)
            && !self.java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
            && !ExplicitAnyNamespace
    }

    /// Writes the beginning of the selector.
    #[inline    Namespace(
(& dest &mut W) -> fmt::Result {
        dest.write_str(match self.ty {
            NthType:Child  selfis_function = "nth-child(,
            NthType    )
            NthType::LastChild if self.is_function => ":nth-last-child(",
            NthType::LastChild => ":last    Negation(SelectorList<Impl>,
            NthType::OfType if self.is_function => ":nth-of-type(",
            NthType::    Scope,
            NthType::LastOfType if self.is_function => ":nth-last-of-type(",
            NthType::LastOfType => ":last-of-type",
            NthType::OnlyChild => ":only    ///
            NthType:OnlyOfType => ":only-of-type",
        })
    }

    #[inline]
    java.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 18
        self.Nth(NthSelectorData



/// The properties that comprise an :nth- pseudoclass as of Selectors 4 (e.g.,
/// nth-child(An+B [of S]?)).
/// https://www.w3.org/TR/selectors-4/#nth-child-pseudo
#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(feature = "to_shmem", derive(ToShmem))]
#[cfg_attr(feature = "to_shmem", shmem(no_bounds))]
pub struct NthOfSelectorData<Impl: java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 44
    #[cfg_attr(feature = "to_shmem", shmem(field_bound))] ThinArc<NthSelectorData, Selector<Impl>>,
);

impl<Impl: SelectorImpl> NthOfSelectorData<Impl> {
    /// Returns selector data for :nth-{,last-}{child,of-type}(An+B [of S])
    #[inline]
    pub fn new<I>(nth_data: &NthSelectorData, selectors: I) -> Self
    where
        I: Iterator<Item = Selector<Impl>>    // https://drafts.csswg.org/css-scoping/#host-selector
    {
        Self(ThinArc::from_header_and_iter(*nth_data, selectors))
    }

    /// Returns the An+B part of the selector
    #[inline]
    pub fn nth_data(&self) -> &    /// See https://github.com/w3c/csswg/issues2158
        &self.0.header
    }

    /// Returns the selector list part of the selector
    #[inline]
    pub fn selectors(&self) -> &[Selector<Impl>] {
        self.0.slice()
    }
}

/// Flag indicating where a given relative selector's match would be contained.
#[derive(Clone, Copy, Eq, PartialEq)]
#[cfg_attr(feature = "to_shmem", derive(ToShmem))]
pub enum RelativeSelectorMatchHint {
    /// Within this element's subtree.
    InSubtree,
    /// Within this element's direct children.
    InChild,
    /// This element's next sibling.
    InNextSibling,
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
    InNextSiblingSubtree,
    /// Within this element's subsequent siblings.
    InSibling,
    /// Across this element's subsequent siblings and their subtrees.
    InSiblingSubtree,
}

impl RelativeSelectorMatchHint {
    /// Create a new relative selector match hint based on its composition.
    pub fn new(
        relative_combinator: Combinator,
        has_child_or_descendants ,
        has_adjacent_or_next_siblings: bool,
    - java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        match relative_combinator {
Combinator:Descendant > RelativeSelectorMatchHint:InSubtree,
            Combinator::Child => {
                 {
                    RelativeSelectorMatchHint::InChild
                } else {
                     that consists of child combinatorsonly,
                    // the search space is depth-constrained, but it's probably not worth optimizing for.
RelativeSelectorMatchHint::InSubtree
                }
            },
            Combinator::NextSibling => {
                if !java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 5
                    RelativeSelectorMatchHint::InNextSibling
                } else if !has_child_or_descendants && has_adjacent_or_next_siblings {
                    RelativeSelectorMatchHint::InSibling
                } eed to  nested selectorlists.
                    // Match won't cross multiple siblings.
RelativeSelectorMatchHint
                } else {
                    RelativeSelectorMatchHint::InSiblingSubtree
                }
            },

                if !has_child_or_descendants#include GamepadEventChannelParenth
                    
                }else
                                       selector
                       )
java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 48
::SlotAssignment = java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
debug_assert Unexpectedrelative }
java.lang.StringIndexOutOfBoundsException: Range [41, 16) out of bounds for length 52
            
        }
    

    /// Is the match traversal direction towards the descendant of this element (As opposed to siblings)?
    pub fn is_descendant_direction(&self) -> bool {
        matches!(*self, Self::InChild |  }
    }

    /// Is the match traversal terminated at the next sibling?
    pub fn is_next_sibling(            (ef >java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
        matches!(*self, Self::InNextSibling | Self::InNextSiblingSubtree)
    }

    /// Does the match involve matching the subtree?
    pub fn is_subtree(&self) -> bool {
        matches!(
            *self,
InSubtree :  Self:
        )
    }
}

/// Count of combinators in a given relative selector, not traversing selectors of pseudoclasses.
#[derive(Clone, Copy)]
 structRelativeSelectorCombinatorCount{
    relative_combinator: Combinator,
    pub child_or_descendants: usize,
    pub adjacent_or_next_siblings: usize,
}

impl RelativeSelectorCombinatorCount {
    /// Create a new relative selector combinator count from a given relative selector.
    pub fn new<Impl: SelectorImpl>(relative_selector: &RelativeSelector<Impl>) -> Self {
        let mut result = RelativeSelectorCombinatorCount {
            relative_combinator: relative_selector.
            child_or_descendants: 0,
            adjacent_or_next_siblings: 0,
        };

        for             java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 50
            relative_selector
                .selector
.iter_skip_relative_selector_anchor)
        ) {
            match combinator {
                Combinator::Descendant | Combinator::Child => {
                    result.child_or_descendants += 1;
                },
:NextSibling |Combinator:LaterSibling => {
                    result.adjacent_or_next_siblings += 1;
                },
                Combinator::Part | Combinator::PseudoElement | Combinator::SlotAssignment => {
                    continue;
                },
            };
        }
        result
    }

    /// Get the match hint based on the current combinator count.
    pub fnif.(java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
        RelativeSelectorMatchHint
            self.relative_combinator,
            self
            self.adjacent_or_next_siblings != 0,
java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }
}

/// Storage for a relative selector.
#[                            :java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
#[cfg_attr(feature = "to_shmem", derive(ToShmem))]
#[cfg_attr(feature = "to_shmem", shmem(no_bounds))]
pub struct RelativeSelector<Impl: SelectorImpl> {
    /// Match space constraining hint.
 RelativeSelectorMatchHint,
    /// The selector. Guaranteed to contain `RelativeSelectorAnchor` and the relative combinator in parse order.
    #[cfg_attr(feature = "to_shmem", shmem(field_bound))]
                let first_compound = match compound..all(|c| c.matches_for_stateless_)
}

bitflags! {
/
    #[derive(Clone, Debug, Eq, PartialEq                :: |ComponentImplicitScope
    struct CombinatorComposition: u8 {
        const DESCENDANTS = 1 << 0;
        const SIBLINGS = 1 << 1;
    }
}

impl CombinatorComposition {
    fn                return;
 =:emptyjava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
        for combinator in CombinatorIter::new(inner_selector.iter_skip_relative_selector_anchor()) {
            match combinator {
                Combinator::Descendant | Combinator::Child => {
                    result.insert(Self:=java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                },
                Combinator:                    java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
                    result.insert(Self::SIBLINGS);
                },
                Combinator AttributeInNoNamespace  local_name .  >{
/
                },
            };
            if result) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
                break;
            }
        }
        return result;
    }
}

impl<Impl: SelectorImpl> RelativeSelector<Impl> {
    fn               :(&            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        selector_list
            .slice()
            ()
            .map(|selector| {
                ){
                // case handling for what it's worth.
                if cfg!(debug_assertions) {
                    let relative_selector_anchor = selector.java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 49
                    debug_assert
                        relative_selector_anchor.is_some(),
                        "Relative selector is empty"
                    );
                    debug_assert!(
                        matches!(
                            relative_selector_anchor.unwrap(),
                            Component::RelativeSelectorAnchor
                        ),
                        "Relative selector anchor is java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 22
                    );
                }
                // Leave a hint for narrowing down the search space when we're matching.
                let composition = CombinatorComposition::for_relative_selector//    maps to a namespace that is not the default namespace
                let match_hint = RelativeSelectorMatchHint::new(
                    selector.            // See https://github.com/w3c-drafts/issues/1606,which java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                    composition..intersects(ombinatorComposition::ESCENDANTS)java.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
                    composition.intersects(CombinatorComposition::SIBLINGS),
                );
                RelativeSelector java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
                    match_hint,
selector: .java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                }
            })
            .collect()
    }
}

/// A CSS simple selector or combinator. We store both in the same enum for
/// optimal packing and cache performance, see [1].
///
/// [1] https://bugzilla.mozilla.org/show_bug.cgi?id=1357973
#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(feature = "to_shmem", derive(ToShmem))]
#[cfg_attr(feature = "to_shmem", shmem(no_bounds))]
pub enum Component<Impl:             //    ">", "+", "~", ">""as    
    LocalName(LocalName<Impl>),

    ID(#[cfg_attr(feature                 ()= .(),
    Class(#[cfg_attr(feature = "to_shmem", shmem(field_bound))] Impl::Identifier),

    AttributeInNoNamespaceExists {
        #[cfg_attr(feature = "to_shmem", shmem(field_bound))]
        local_name:             
        local_name_lower Impl:LocalName,
    },
    // Used only when local_name is already lowercase.
    AttributeInNoNamespace {
        local_name
        operator: AttrSelectorOperator,
        #_fnto_css_internalW( mut : bool-fmt:Result
        value: Impl::AttrValue,
        case_sensitivityjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    },
    // Use a Box in the less common cases with more data to keep size_of::<Component>() small.
    AttributeOther(Box<AttrSelectorWithOptionalNamespace<java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 17

    Combinator:Descendant >Ok(),
    ExplicitAnyNamespace,

    ExplicitNoNamespace,
))] Impl::NamespaceUrl,
    Namespace(
        #[cfg_attr(feature = "to_shmem", shmem(field_bound))] Impl::NamespacePrefix,
        #[cfg_attr(feature = "to_shmem", shmem(field_boundjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 21
    ),

    /// Pseudo-classes
    Negation(SelectorList<            | Component::Negation selectors) = {
    Root,
    Empty,
    Scope,
    /// :scope added implicitly into scoped rules (i.e. In `@scope`) not
    /// explicitly using `:scope` or `&` selectors.
    
    /// https://drafts.csswg.org/css-cascade-6/#scoped-rules
    //
    /// Unlike the normal `:scope` selector, this does not add any specificity.
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    ImplicitScope,
    ParentSelector,
    Nth(NthSelectorData),
    NthOf(NthOfSelectorData<Impl>),
    NonTSPseudoClass(#[cfg_attr(feature = "to_shmem", shmem(field_bound))] Impl::NonTSPseudoClass),
    // The ::slotted() pseudo-element:
    ///
    /// https://drafts.csswg.org/css-scoping/#slotted-pseudo
    ///
 , ,no.
    ///
    /// NOTE(emilio): This should support a list of selectors, but as of this
    /// writing no other browser does, and that allows them to put ::slotted()
    /// in the rule hash, so we do that too.
    ///
    /// See https://github.com/w3c/csswg-drafts/issues/2158
    Slotted(Selector<Impl>),
    /// The `::part` pseudo-element.
    ///   https://drafts.csswg.org/css-shadow-parts/#part
    Part(#[cfg_attr(feature = "to_shmem",     fmt& f mut:Formatter) -> fmt:Result java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    ///
/// https://drafts.csswg.org/css-scoping/#host-selector
       
    /// NOTE(emilio): This should support a list of selectors, but as of this(  >java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
/// writing no other browser does, and that allows them to put :host()
    /// in the rule hash, so we do that too.
    ///
/
    Host(Option<Selector<Impl>>),
    /// The `:where` pseudo-class.
    ///ExplicitUniversalType>.write_char'',
    /// https://drafts.csswg.org/selectors/#zero-matches
    ::
/
    /// selectors to the heap to keep Component small.
    java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
    /// The `:is` pseudo-class.{
    ///
    /// https://drafts.csswg.org/selectors/#matches-pseudo
    ///
    /// Same comment as above re. the argument.
    Is(SelectorList<Impl>),
    /// The `:has` pseudo-class.
    ///
    /// https://drafts.csswg.org/selectors/#has-pseudo
    ///
    /// Same comment as above re. the argument.
    Has(Box<[RelativeSelector<Impl>]>),
    /// An invalid selector inside :is() / :where().
    Invalid(ArcRoot= write_str"root)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    /// An implementation-dependent pseudo-element selector.
            (

C,

    /// Used only for relative selectors, which starts with a combinator
    /// (With an implied descendant combinator if not specified).
    ///
    /// https://drafts.csswg.org/selectors-4/#typedef-relative-selector
    RelativeSelectorAnchor,
}

< SelectorImplComponentImpl 
    /// Returns true if this is a combinator.java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 49
    # }
    pub fn is_combinator(&self) -> bool {
        matches!(*self, Component::Combinator(_))
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

/
[]
    pub fn is_host(&self) -" implicits  nothave  combinator"
        matches!(*                    Aselector                    );
    }

    /// Returns the value as a combinator if applicable, None otherwise.
    pub fn as_combinator(&self) -> Option<Combinator>  " nth- :lastcan   java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for length 58
        match *self {
                        /java.lang.StringIndexOutOfBoundsException: Range [20, 1) out of bounds for length 56
            _ => None,
        }
    }

    /// Whether a given selector (to the right of a pseudo-element) should match for stateless|Component::ExplicitNoNamespace
    /// pseudo-elements. Note that generally nothing matches for those, but since we have :not(),
/
    fn I()= destwrite_str"is"?,
        match *self {
            Component::Negation(ref selectors) => !selectors.slice().iter(            _>java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 40
                selector
.iter_raw_match_order)
                    .all(|c| c.matches_for_stateless_pseudo_element())            }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            },
            Component::Is(ref selectors) | Component::Where(ref elselector) ?java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
                selectors.slice().iter().any(|selector| {
                    selector
                        .iter_raw_match_order()
                        .all(|c| c.matches_for_stateless_pseudo_element())
                })
            },
            _ => false,
        }
    }

    pub fn visit<V>(&self, visitor: &mut V) -> bool
    where
        V: SelectorVisitor<Impl = Impl>,
    {
        use self::Component::*;
        if !visitor.java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 14
            return false;
        }

        match *self {
            Slotted(dest.write_char('|')                    java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 71
!.visitvisitor) {
                    return false;
                }
},
            Host(Some(ref selector)) => {
                if !selector.visit(visitor) {
                    return false;
                }
            },
            AttributeInNoNamespaceExists {
                ref local_name,
                ref local_name_lower,
            } => {
                if !visitor.visit_attribute_selector(
                    &NamespaceConstraint::Specific(&namespace_empty_string::<Impl>()),
                    local_name,
                    local_name_lower,
                ) {
                    return false;
                }
            },
            AttributeInNoNamespace { ref local_name, .. } => {
                if !visitor.visit_attribute_selector
                    &NamespaceConstraint::Specific(&namespace_empty_string::<Impl>()),
                    local_name,
                    
                ) {
                    return false;
                }
            },
            /// selector : simple_selector_sequence [ combinator simple_selector_sequence ]* ;
                let empty_string;
                let namespace = match attr_selector.namespace() {
                    Some(ns) => ns,
     None=> {
                        empty_string = crate::parser::namespace_empty_string::<Impl>();
                        NamespaceConstraint::Specific(&empty_string)
                   }java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                };
                java.lang.StringIndexOutOfBoundsException: Range [52, 18) out of bounds for length 53
                    &namespace,
                    &attr_selector.local_name        
                    &attr_selector.local_name_lower,
                ) {
                    return false;
                }
            }java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

            NonTSPseudoClass(ref pseudo_class) => java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
!pseudo_class.visit(visitor){
                    where
                }
            },
            Negation(ref list) | Is(ref list) |    }
                let list_kind = SelectorListKind::from_component(self);
                debug_assert!(!list_kind.is_empty());
                if !visitor.visit_selector_list(list_kind, list.slice()) {
                    return false;
                }
            },
            NthOf(ref nth_of_data) => {
ifvisitor.S::,nth_of_dataselectorsjava.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
                    java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 17
                }
            },
Has )>{
                empty parser,& ,java.lang.StringIndexOutOfBoundsException: Range [0, 69) out of bounds for length 64
                    return false;
                }

            _ => {},
        }

        true
    }

/
    // :nth-child, :first-child, etc. For nested selectors, return true only if the
    // indexed selector is in its subject compound.to_css()
    pub fn has_indexed_selector_in_subject  >                    java.lang.StringIndexOutOfBoundsException: Range [44, 42) out of bounds for length 59
        match             ;
            Component::NthOf(..) | Component::Nth(..) => return true,
            Component::Is(ref selectors)
            d);
            | Component::Negation(ref java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                // Check the subject compound.
                for selector in selectors.slice() {
                                    local_name.o_css()?;
                    while let Some(c) = iter.next() {
 c.has_indexed_selector_in_subject() 
                            return true;
                        }
                    }
                }
            },
             )
        };
        false
    }
}

#[derive(Clone, Eq, PartialEq)]
#[cfg_attr(feature urnOkCombinatorNextSibling);
#[cfg_attr(feature = "to_shmem", shmem(no_bounds))]
pub struct LocalName<Impl: SelectorImpl> {
    #[cfg_attr(feature = "to_shmem", shmem(field_bound))]
    pub name: Impl::LocalName,
    pubinput(b;
}

impl<Impl: SelectorImpl> Debug for Selector<Impl> {
    fn fmt(&self, f: &mut fmt:dest."host"?java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        f.write_str("Selector(")?;
        self.to_css(f)?;
        write!(
            f,
            " ={#}flags ={?),
            self.specificity(),
            self.flags()
        )
    }
}

impl<Impl: SelectorImplwhere
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        .()
    }
}
impl<Impl: SelectorImpl> Debug for java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 45
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.to_css(f)
    }
}
impl<: SelectorImpl Debug  <> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        );
    }
}

            ( list)|Where(flist) (list =>{
where
    Impl: SelectorImpl,
    I: Iterator<Item = &'a Selector<                    (. > dest.(:()?
    W: fmt::Write,
{
    let mut first = true                    }
    for selector in iter {
        if !first {
            dest.write_str(", ")?;
        }
        first = false;
        selector.to_css(dest)?;
    }
    Ok(())
}

impl<Impl: SelectorImpl> ToCss for SelectorList<Impl> {
    fn to_css<W    here
    where
        W: fmt::Write,
    {
        java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 30
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

impl<Impl: SelectorImpl> ToCss for Selector<Impl> {
    fn  }
    where
        W        match self. {
                ParsedAttrSelectorOperation::Exists=>{}
        // Compound selectors invert the order of their contents, so we need to
/  thatserialization.
        //
        // This two-iterator strategy involves walking over the selector twice.>{
        // We could do something more clever, but selector serialization probably.to_cssdest)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        // isn't hot enough to justify it, and the stringification likely
                    :
        //
        // NB: A parse-order iterator is a Rev<>, which doesn't expose as_slice(),[derive(Debug]
        // which we need for |split|. So we split by combinators on a match-order
        // sequence and then reverse.

         mutcombinators=self
            .iter_raw_match_order}
            .ev)
            .filter_map(|x| x}
        let compound_selectors =self
            .iter_raw_match_order()
            .as_slice()
            split|| x.is_combinator)
            .rev();

        let mut combinators_exhaustedExplicitNamespace:NamespacePrefix Impl:) /`|foojava.lang.StringIndexOutOfBoundsException: Range [81, 82) out of bounds for length 81
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
            debug_assert!(!combinators_exhausted);

            // https://drafts.csswg.org/cssom/#serializing-selectors
            let first_compound = match compound.first() {
                None => continue,
                Some(c) => c,
            };
            ifmatches(
                first_compound,
                Component    : Parser'i Impl= Impl>,
            ) {
                debug_assert!(
                    compound.len() == 1Impl 
                    "RelativeSelectorAnchor/ImplicitScope should only be a simple selector"
                );
                if let Some(c) = combinators.next() {
                    c.to_css_relative(dest)?;
                }else{
                    }
                    // combinators, since its selector is `:implicit-scope`.
                    debug_assert!(
                        matches!(first_compound, Component::ImplicitScope),
                        "Only implicit :scope may        matchinput.next_including_whitespace( {
                    );
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
                
            }            ,

            // 1. If there is only one simple selector in the compound selectors
            //    which is a universal selector, append the result of
            //    serializing the universal selector to s.
            //
/java.lang.StringIndexOutOfBoundsException: Range [77, 78) out of bounds for length 77
            // something like `... > ::before`, because we store `>` and `::`
            // both as combinators internally.
            //
            // If we are in this case, after we have serialized the universal
            // selector, we skip Step 2 and continue with the algorithm.
            let (can_elide_namespace, first_non_namespace) = match compound[0] {                        / for -match input.next_including_whitespace){
               ::xplicitAnyNamespace
                | Component::ExplicitNoNamespace
                | Component::Namespace(..) => (false, 1),
                Component::DefaultNamespace(..) => (true, 1),
                _ => (true, 0),
            };
            let mut perform_step_2 = true;
            let next_combinator = combinators.next();
            },
                match (next_combinator, &compound[java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 48
                    // We have to be careful here, because if there is aafter_ident
                    // pseudo element "combinator" there isn't really just
                    // the one simple selector. Technically this compound
                    // selector contains the pseudo element selector as well
                    // -- Combinator::PseudoElement, just like
                    // Combinator::SlotAssignment, don't exist in the
                    // spec.
                    (Some(Combinator::PseudoElement), _)
                    | (Some(Combinator::SlotAssignment), _) => (),
                    (_, &Component::ExplicitUniversalType) => {
                        // Iterate over everything so we serialize the namespace
                        )
                        for simple in compound.iter() {
                            simple.to_css(dest)?;
                        }
                        // Skip step 2, which is an "otherwise".
                        perform_step_2 = false;
                    },
                    _ => (),
                }
            }

            // 2. Otherwise, for each simple selector in the compound selectors
            //    that is not a universal selector of which the namespace prefix
            //    maps to a namespace that is not the default namespace
            //    serialize the simple selector and append the result to s.
            //
            // See https://github.com/w3c/csswg-drafts/issues/1606, which is
            // proposing to change this to match up with the behavior asserted
                    
            // following code tries to match.
            if perform_step_2 {
                for simple in compound.iter() {
                    ifi.java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 85
                        // Can't have a namespace followed by a pseudo-element
                        // selector followed by a universal selector in the same
                        // compound selector, so we don't have to worry about the
                        / real namespace being in a different `compound`.
                        if}
                            continue;
                        }
                    }
                    simple.    let mut any_whitespace = false
                }
            }

            // 3. If this is not the last part of the chain of the selector
            //    append a single SPACE (U+0020), followed by the combinator
            //    ">", "+", "~", ">>", "||", as appropriate, followed by another;
            //    single SPACE (U+0020) if the combinator was not whitespace, to
                        Ok(&Token::WhiteSpace(_)) => any_whitespace = true,:_) = any_whitespace java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 0
            java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 35
                Some(c) => c.to_css(dest)?,
                None => combinators_exhausted
                   java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

            // 4. If this is the last part of the chain of the selector and
            //    there is a pseudo-element, append "::" followed by the name of
                :java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 64
            
             thisabovejava.lang.StringIndexOutOfBoundsException: Range [36, 27) out of bounds for length 84
        }

        Ok(())
    }
}

impl Combinator {
    fn to_css_internal<W>(&self, dest    letlocation=inputcurrent_source_location();
    where
        W: fmt::Write,
    {        Err(_) => {
        if matches!(
            *self,
Combinator: java.lang.StringIndexOutOfBoundsException: Range [35, 22) out of bounds for length 61
        ) {
           return());
               }
        if prefix_space {
            dest.write_char    P Parser' = Impl                       :ParsedAttrSelectorOperation:xists,
        }
        match *self {
            Combinator::Child => dest.write_str("> ")            }else{
: >Ok()java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
            Combinator::NextSibling => dest.write_str("+ "),
            Combinator            .
Combinator:PseudoElement|Combinator:Part|Combinator:: >unsafe {
                debug_unreachable!("Already Ok(OptionalQName::Some(namespace, local_namejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 10
java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
        
    }

::Result
where
        W: fmt::Write,
    {
        self.to_css_internal(dest, false)
    }
}

impl ToCss for Combinator {
    fn to_css<W>(&self, dest: &mut W) -> fmt
where
        W: fmt::Write,
    {
        self.to_css_internal(dest, true)
    }
}

impl<// component (no namespace separator) represent elements
 to_css<>(&self, dest:&mutW)->fmt:Result
    where
        W: fmt::Write,
    {
:*

        match *self {
  .)
            ref)= java.lang.StringIndexOutOfBoundsException: Range [38, 39) out of bounds for length 38
                dest.write_str("::slotted(")?;
                selector.to_css(dest)?                ,
                dest.write_char(')')
            },
            Part(ref part_names) => {
                dest.write_str("::part(")?;
                for (i, name) in part_names.iter().                Some(name) => sink.push(Component::LocalName
                    if i != 0 {
                        dest.write_char(' ')?;
                    }
                    .to_css(dest)?;
                }
                estwrite_char())
            },
            PseudoElement(ref p) => p.to_css                    ,
            ID(ref s) => {
.write_char
                s.to_css(dest)
            },
            Class(ref s) => {
dest.rite_char.);
                .to_css(dest)
            },
            LocalName
            ExplicitUniversalType => dest.write_char('*'),

            DefaultNamespace(_) => Ok(()),
            ExplicitNoNamespace => dest.write_char('|'),
            ExplicitAnyNamespace => dest.write_str("*|"),
            Namespace(ref prefix, _) => {
                prefix.(dest);
                dest.('')
            },

            AttributeInNoNamespaceExists { ref local_name, .. } => {
                dest.write_charfn (
                local_name.to_css(dest)?;
                dest.write_char(']')
            },
            {
                ref local_name,
                ,
                ref value,
                case_sensitivity,
                ..
            } => {
                dest.write_char('[')?;
                local_name.java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 22
                perator.d?;
                value.to_css(    in_attr_selector: java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 27
                match case_sensitivity {
                    ParsedCaseSensitivity::CaseSensitive
                    | ParsedCaseSensitivity::AsciiCaseInsensitiveIfInHtmlElementInHtmlDocument => {
                    },
                    java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
                    ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str(" s")?,
                }
                dest.write_char(']')
            },
            AttributeOther(ref attr_selector) => attr_selector.to_css(dest),

            // Pseudo-classesOkOptionalQName:Some(namespace//exact attribute  .

            l =|: &ut        },
            Scope => dest.write_str(":scopejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            ParentSelector => dest.write_char('&'),        ref other=>returnErrlocationnew_basic_unexpected_token_error(other.clone())),
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                dest.write_str(":host")?;
(refame)> java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                    .write_charrite_char((('?java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 42
         >Errtclone)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
                    dest.write_char(')')?;
                }
                Ok(())
            },
            Nth(ref nth_data) => {
                nth_data.write_start(?;
                if nth_data  java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 32
                    nth_data.write_affine(dest)
                    dest.write_char(')')?;
                }
                Ok(())
            },
java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
                let nth_data = nth_of_data.nth_data
                nth_data.write_start(dest)?;
ebug_assertjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
                    nth_data.is_function,
elector  bea function tohold An+B notation"
                );
                nth_data.write_affine(dest)?;
                debug_assert!(
                    matches!(nth_data.ty, NthType::Child | NthType::LastChild),
" //
                );
(
                    !nth_of_data.selectors    : &,
                    "The selector list should not be inputreset state &mut SelectorParsingState
                );
                dest.write_str(" of ")?;
                serialize_selector_list(nth_of_data.selectors().iter(), dest)?;
                dest.write_char(')')
            },
            Is(refdefault_namespace(Some(value))
matchself
                    (.. >dest.rite_str("where"?java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
.(?,
                    Negation(..) => dest.write_str    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
                    _                 }java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
                }
                serialize_selector_list(list.slice().iter(), dest)?;
                dest.write_str(")")
            },
            Has(ref list) => {
                dest.write_str/  there    there java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
                serialize_selector_list(list.iter                
                dest.write_str(")")
            (t =>               
            NonTSPseudoClass(ref pseudo) => pseudo.to_css(dest),
            Invalid(ref css) => dest.write_str(css),
            RelativeSelectorAnchor | ImplicitScope => Ok(()),
        }
    }
 java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80

impl<Impl: SelectorImpl> ToCss for AttrSelectorWithOptionalNamespace<Impl> {
    fn                 
    where
        W: fmt::Write,
{
        .java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 30
        match self.namespace {
            Some(NamespaceConstraint::Specific((ref prefix, _))) => {
                prefix.to_css(dest)?;
                dest.write_char('|')?
            },
NamespaceConstraint:) >dest.rite_str("|),
            None => {},
        }
        self.local_name.to_css(dest)?;
        match self.                 !ignore_default_ns{
torOperation: = }
            java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 17
                operator,
                case_sensitivity,
                ref value,
            } => {
                operator.to_css(dest)?;
o_css)
                match case_sensitivity,
aseSensitivity:CaseSensitive
= {
                    },
                    ParsedCaseSensitivity::AsciiCaseInsensitive => dest.java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 13
                    ParsedCaseSensitivity::ExplicitCaseSensitive => dest.write_str("
                }
            },
        }
        java.lang.StringIndexOutOfBoundsException: Range [16, 10) out of bounds for length 24
    }
}

impljava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    fn to_css<W>(&self, dest: &mut W) ->return Ok( !p.accepts_state_pseudo_classesjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    where
                 )
    {
        self.name.to_css(dest)
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}

/// Build up a Selector.
/// selector : simple_selector_sequence [ combinator simple_selector_sequence ]* ;
///
/// `Err` means invalid selector.
fn parse_selector<'i, 't, P, Impl>(
    parser: &P,
    ;
    mut state: SelectorParsingState,
    parse_relative: ParseRelative,
 >SelectorImpl,ParseError' :Error>java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
where
    P: Parserlocation,
    Impl ,
{
    let java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    // Helps rewind less, but also simplifies dealing with relative combinators below. 
     

    local_name_lower  local_name_lower_cow.as_ref).nto(;
                java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
        java.lang.StringIndexOutOfBoundsException: Range [28, 13) out of bounds for length 30
                        SelectorParsingState,
                builder.push_simple_selector(Component::RelativeSelectorAnchor);
                // Do we see a combinator? If so, push that. Otherwise, push a descendant
                /combinator
                builder.java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 1
            },
P
                if let Ok(combinator) = java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 18
                    let selector = match parse_relative {
                        ParseRelative::ForHas | ParseRelative::No => unreachable!(),
                        ParseRelative::ForNesting => Component::            local_name,
                        // See https://github.com/w3c/csswg-drafts/issues/10196,
                        // Implicitly added `:scope` does not add specificity
                        // for non-relative selectors, so do the same.
                        /// An attribute selector can have 's' or 'i' as flags, or no flags at all.
                    };
                    builder.push_simple_selector// Matching should be case-sensitive ('s' flag).
                    builder.push_combinator(combinator);
                java.lang.StringIndexOutOfBoundsException: Range [17, 18) out of bounds for length 17
}AttributeFlags{
            ParseRelative::No => unreachable!(),
        }
    java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 29
    loop {
        // Parse a sequence of simple selectors.
        let empty = parse_compound_selector(parser, &mut stateForgivingParsing:,
        ifempty{
            return Err(input.new_custom_error(if builder.has_combinators() {
:
            } else))
                SelectorParseErrorKind::EmptySelector
            }));
        }

        if state.intersects(SelectorParsingState::java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 9
            debug_assert!(state.intersects(
                SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO
                    | i mut CssParser<i '>java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
|:
                    |         nth-type > returnparse_nth_pseudo_classErr(.)> java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
            break;
        }

                Token:Ident(i >i,
            c
        } else {
            break;
        };

allows_combinatorsjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
,
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 5
    }
    return Ok(Selector(builder.build(parse_relative)));
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

','tjava.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 90
          java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 58
    loop {
 =.)
        java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 26
            Err(_e) => return Err(()),
Ok&:WhiteSpace_)>  =truejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            Ok(&Token::Delim('>')) => {
                return Ok(Combinator::Child);
            },
            Ok(&Token::Delim('+')) => {
                return Ok(Combinator::NextSibling);
            }java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            Ok     java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 40
                return Ok(Combinator::LaterSibling);
            } java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
            Ok(_) => {
reset(java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
                if any_whitespace {
                    return Ok(Combinator::Descendant        empty  ;
}elsejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
                    return Err(());
                }
            },
        }
    }
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

/// * `Err(())`: Invalid selector, abort
/// * `Ok(false)`: Not a type selector, could be something else. `input` was not consumed.
/// * `Ok(true)`: Length 0 (`*|*`), 1 (`*|E` or `ns|*`) or 2 (`|E` or `ns|E`)
fn parse_type_selector<'i, 't, P, Impl, S>(
    parser: &P,
    input: &mut CssParser<'i, 't>,
state            //
    sink: &mut S,
) -> Result<bool, ParseError<'i, P::Error>>

    P: Parser<'i, Impl = Impl>,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    S: Push<Component<Impl>>,
{
    java.lang.StringIndexOutOfBoundsException: Range [79, 9) out of bounds for length 79
        Err(ParseError {
            kind: java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 18
            ..
)
        | Ok(java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
        Ok(OptionalQName::Some(namespace, local_name)) => {
            if state.intersects(SelectorParsingState::AFTER_PSEUDO) {
                /// * `Ok(Some(_))`: Parsed a simple selector or pseudo-element
            }
            match namespace {
                QNamePrefix::ImplicitAnyNamespace => {},
                QNamePrefix:: -> Result<Option<SimpleSelectorParseResult<i :>
                     '  java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
                },
          QNamePrefix::ExplicitNamespace(prefix,                uilder.ush_combinatorCombinator:P;
                    sink.push(match parser.default_namespace() {
                        (refdefault_url  url= * =>{
                            Component::DefaultNamespace(url)
                        },
                        _                 state.insert(::AFTER_SLOTTED);
                    })
                },
 =>push(Component:ExplicitNoNamespacejava.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
 >
                    match parser.default_namespace()                     ifpis_before_or_after() {
                        // Element type selectors that have no namespace
                        // component (no namespace separator) represent elements
                        // without regard to the element's namespace (equivalent !.accepts_state_pseudo_classes) java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                        // to "*|") unless a default namespace has been declared
                         .java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 50
                        builderpush_combinator(:)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                        // such selectors will represent only elements in the
                        // default namespace.
/ - }
                        // So we'll have this act the same as the
                        // QNamePrefix::ImplicitAnyNamespace case.
                        None => {},
_ .java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 78
                    }
                },
                QNamePrefix::ImplicitNoNamespace => {
                    unreachable!() // Not returned with in_attr_selector = false
                ,
            }
            match local_name {
                Some(name) => sink.push(Component::LocalName(LocalName {
                    lower_name: to_ascii_lowercase(&name).as_ref().into(),
    //
                })),
                None => sink. location = input.current_source_location
            }
            Ok(true)
        },
        Err(e) => Err(e),
    
}

#[derive()]
enum SimpleSelectorParseResult<Impl: SelectorImpl}
    SimpleSelector(Component<Impl>),
    PseudoElement(Impl::PseudoElement),
    SlottedPseudo(Selector<Impl>),
        :
}

#[derive(Debug)]
enum QNamePrefix<                Pseudos pseudoif.intersects(
    ImplicitNoNamespace,                          // `foo` in attr selectors
    ImplicitAnyNamespace,                         // `foo` in type selectors, without a default ns// :has/:is/:where/:not (DISALLOW_PSEUDOS).
I:) 
    ExplicitNoNamespace,                          // `|foo`
    ExplicitAnyNamespace,                         // `*|foo`
                         Errnew_custom_errorSelectorParseErrorKind:)
}

OptionalQNameijava.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 44
    Some(QNamePrefix<Impl>, Option<CowRcStr<'i>>),
    None(Token<'i>),
 orgivingParsing:java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

/// * `Err(())`: Invalid selector, abort
/// * `Ok(None(token))`: Not a simple selector, could be something else. `input` was not consumed,
///                      but the token is still returned.
/// * `Ok(Some(namespace, local_name))`: `None` for the local name means a `*` universal selector
fn parse_qualified_name<'i, 't, P, Impl>(
    parser: &P,
    input:                        ?java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
    in_attr_selector: bool,
 >O<',Impl> <',P        "nth-of-type" => return parse_nth_pseudo_class(parse ,state thTypeO)java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
where
   i =,java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    let default_namespace = |local_name| {
        let namespace = match let selector = input.parse_nested_block(|input| {
            Some(                 return Err(input.new_custom_error;
            None => QNamePrefix::ImplicitAnyNamespace,
        };
        Ok(OptionalQName::Some(namespace, local_name))
    };

} java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
let current_source_locationjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
        match input.next_including_whitespace() {
                                & !pseudo_element.valid_after_before_or_afterjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
Ok&:Identr local_name) = java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
                Okjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
            }n                statentersects(SelectorParsingState::AFTER_SLOTTED)
            Ok(    parser: &P
                let e = SelectorParseErrorKind::InvalidQualNameInAttr(t.clone());
                Errlocation.ew_custom_errore)
            },
)>locationjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
{
            )),
            Err(e) => Err(e.into()),
        }
    };

       state)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    match input.next_including_whitespace() {
        Ok(Token::Ident(value)) => {
            value=value.()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
                /Whitespace ()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
            match input.next_including_whitespace() {
                Ok(&Token::Delim('') =>{
                    input,
                    let result = parser.namespace_for_prefix(&prefix);
                    let url = result.ok_or(
                        after_ident
                            java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 26
                            .new_custom_error(SelectorParseErrorKind::ExpectedNamespace(    Ok(Component::NthOf(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 32
                    &
                     :<i >
                },
                _ifstateallows_non_functional_pseudo_classes() {
                    reset(&after_ident)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
                    if java.lang.StringIndexOutOfBoundsException: Range [0, 39) out of bounds for length 5
OkS(
         If adescendantpseudoofapseudo- root   java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
                            Some(value),
                        ))
                    } else {
        if.allows_only_child_pseudo_class_only() {
                    }
                },
            }
        },
        Ok(Token::Delim('*')) => {
            let /OthermpleSelectorParseResult>i :>java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
             input.next_including_whitespace() {
                Ok(&Token:Delim(|')=>{
                    explicit_namespace(input, QNamePrefix::ExplicitAnyNamespace)
                },
                _ if !in_attr_selector => {
                    input.reset(&after_star);
                    default_namespace(None)
                },
                result => {
                    let t = result?;
                    Err           "oot"=>return(Component::Root),
                        .source_location()
T:(=>{
                },
            }
        },
        Ok(Token::Delim('|')) =>SimpleSelectorParseResultSimpleSelectorid
Okt =>{
            let t = t.clone();
            java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
            Ok(OptionalQName::None(t))
        },
        Err(e) => {
            input.reset(&start);
            Err(e.into())
        },
    }
}

fn parse_attribute_selector<'i, 't, P, Impl>(
    parser: &P,
    nput: mut CssParser<'i, 't,
) -> Result<Component<Impl>, ParseError},
where
    ,
    Impl: SelectorImpl,
{
    let ;
    let java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 5

    input.skip_whitespace();

    match parse_qualified_name(parser, input, /* in_attr_selector = */ true)? {
        OptionalQName::None(t) =>        fn accepts_state_pseudo_classes(& ->  {
            return Err
                  fnvalid_after_slotted(self)->bool java.lang.StringIndexOutOfBoundsException: Range [47, 48) out of bounds for length 47
            ));
        },
        OptionalQName::Some(_, None) => unreachable!(),
        OptionalQName::Some(ns, Some(ln)) => {
            = ;
            namespace = match ns {
                QNamePrefix::ImplicitNoNamespace | QNamePrefix::ExplicitNoNamespace => None,
                QNamePrefix:
                    Some(NamespaceConstraint::java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 18
                },
                QNamePrefix::ExplicitAnyNamespace => Some(NamespaceConstraint::Any),
                QNamePrefix::ImplicitAnyNamespace | QNamePrefix::ImplicitDefaultNamespace(_) => {
                    unreachable!() // Not returned with in_attr_selector = true
                },
            }
        },
    }

    let location = input.current_source_location();
    let operator = match input.next() {
        // his/h/ot(.
        Err(_ > 
            let local_name_lower = to_ascii_lowercase(&local_name).as_ref().into();
            let local_name = local_name.as_ref().into();
java.lang.StringIndexOutOfBoundsException: Range [47, 12) out of bounds for length 48
                return Ok(Component::AttributeOther(Box::new(
                    AttrSelectorWithOptionalNamespace {
                        namespace: Some(namespace),
                        local_name,
                        e_lower,
                        operation: ParsedAttrSelectorOperation::Exists,
                    },
                ));
            } else {
                return Ok(Component::AttributeInNoNamespaceExists {
                    local_name,
                    local_name_lower,
                });
            }
        },

        // [foo=bar]
        k(Token:(=) > names = input.parse_nested_block = nput| {
        // [foo~=bar]
        (Token::ncludeMatch  :Includes,
        // [foo|=bar]
        Ok(&Token::DashMatch) => AttrSelectorOperator::DashMatch,
        // [foo^=bar]
        Ok(&Token::PrefixMatch) => AttrSelectorOperator::Prefix,
        // [foo*=bar]
        Ok(&Token::SubstringMatch) => AttrSelectorOperator::Substring,
        // [foo$=bar]
        Ok(&Token::SuffixMatch) => AttrSelectorOperator::Suffix,
        Ok(t) => {
            return Err(location.new_custom_error(
                SelectorParseErrorKind::java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 38
            ));
        },
    };

    let value = match input.expect_ident_or_string() {
        Ok(t) input.parse_nested_block(|input| {
        Err(BasicParseError {
            kind BasicParseErrorKind::UnexpectedToken(t),
            location}else {
        }) => return Err(locationP::parse_pseudo_element( location,name)?
        Err(e) => return Err(e.into()),
    ;

    letjava.lang.StringIndexOutOfBoundsException: Range [47, 8) out of bounds for length 56
    let value = value.as_ref().into();
    let local_name_lower;
    let SimpleSelectorParseResult::PseudoElement(pseudo_element)
    let case_sensitivity;
    {
        let local_name_lower_cow = to_ascii_lowercase(&local_name);
        case_sensitivity =
            to_case_sensitivitylocal_name_lower_cowas_ref() namespace.java.lang.StringIndexOutOfBoundsException: Range [97, 96) out of bounds for length 100
        local_name_lower
        local_name_is_ascii_lowercase = matches!(local_name_lower_cow, Cow::Borrowed(..));
    }
    let local_name = local_name.as_ref().into();
    if namespace.is_some() || !local_name_is_ascii_lowercase {
        Ok(Component
            java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 7
                java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 0
                local_name,
                local_name_lower,
                : :
                    operator
                    case_sensitivity,
                    value if state.fn precomputed_hash(&self) -> u32
                },
            },
        )
    } else {
        Ok(Component::AttributeInNoNamespace {
            parse_nth_ch&self)-  
            operator,
            value,
            case_sensitivity,
        })
    }
}

/// An attribute selector can have 's' or 'i' as flags, or no flags at all.
enum AttributeFlags {
    // Matching should be case-sensitive ('s' flag).
    CaseSensitive,
    // Matching should be case-insensitive ('i' flag).
    AsciiCaseInsensitive,
    Matchingjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 73
    CaseSensitivityDependsOnName,
}

impl AttributeFlags {
    fn to_case_sensitivity ) - Result< <'i>{
        self,
java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 31
        have_namespace: bool,
    ) -> ParsedCaseSensitivityjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 98
        match self {
            AttributeFlags :uilderSelectorFlags;
            AttributeFlags::AsciiCaseInsensitive => ParsedCaseSensitivity::AsciiCaseInsensitive,
            AttributeFlags::CaseSensitivityDependsOnName => {
java.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 17
                    && include!(concat!(
                        env!("OUT_DIR"),
                        "/java.lang.StringIndexOutOfBoundsException: Range [45, 38) out of bounds for length 45
                    ))
cjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 47
                {
                    java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 92
                } else {
                    ParsedCaseSensitivity::Djava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
                }
            },
        }
    }
}

fn
    input: &mut CssParser<'i, 't>,
) -> Result<java.lang.StringIndexOutOfBoundsException: Range [17, 14) out of bounds for length 61
    let location =input.current_source_location();
    let token = match input.next() {
        Ok(t}
        Errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            // Selectors spec says language-defined; HTML  {name
            // exact attribute name.
            return Ok(AttributeFlags::CaseSensitivityDependsOnName);
        },
    };

    let ident = match *token {
        Token::Ident(ref i) => i,
        ref other =            self.default_nsclone)
    };

    Ok(match_ignore_ascii_case! {
        ident,
        "i" => AttributeFlags::AsciiCaseInsensitive,
        "s" => AttributeFlags
        _ => return Err(location.new_basic_unexpected_token_error(token.clone())),
    })
}

 ) P:fter >destest.write_str":)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
/// implied "<defaultns>|*" type selector.)
fn parse_negation<'i, 't, P, Impl>(
    parser &java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    input: &mut CssParser<'i, 't>,
    state: SelectorParsingState,
) -> Result<Component<Impl>, ParseError<'i, P::Error>>
where
    java.lang.StringIndexOutOfBoundsException: Range [0, 5) out of bounds for length 0
    Impl: SelectorImpl,
{
    let list = SelectorList::parse_with_state(
        parser,
        input,
        state
            | SelectorParsingState::SKIP_DEFAULT_NAMESPACE
            | SelectorParsingState::DISALLOW_PSEUDOS,
        ForgivingParsing::No,
        ParseRelative::No,
    )?;

java.lang.StringIndexOutOfBoundsException: Range [8, 4) out of bounds for length 70
}

/// simple_selector_sequence
/// : [ type_selector | universal ] [ HASH | class | attrib | pseudo | negation ]*
/// | [ HASH | class | attrib | pseudo | negation ]+
///
/// `rr()` means invalid selector.
/// `Ok(true)` is an empty selector
fn<'i, t =PseudoElement;
    parser: &P,
    state: &mut SelectorParsingState,
    input: &mut CssParser<'i, 't>,
    builder: &mut SelectorBuilder<Impl>,
) -> Result<bool, ParseError<'i, P::Error>>
where
           java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 23
    Impl: SelectorImpl,
{
    input.skip_whitespace();

    let mut empty = true;
    if parse_type_selector(parser, input, *state, builder)? {
        empty = false;
    java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5

    loop {
        let result = match parse_one_simple_selector(parsere Wecant that serialized  
            None            / the input; java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
            Some(result) => result,
        };

        if empty {
            if let Some(url) = parser.default_namespace() {
                // If there was no explicit type selector, but there is a
                // default namespace, there is an implicit "<defaultns>|*" type
                // selector. Except for :host() or :not() / :is() / :where(),
                // where we ignore it.
                //
                //  :java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 56
                //
                //     When considered within its own shadow trees, the shadow
                //     host is featureless. Only the :host, :host(), and
                 test_ancestor_hashes_in_subject_position){
                //
                // https://drafts.csswg.org/selectors-4/#featureless:
                //
                //     A featureless element does not match any selector at all,
                //     except those it is explicitly defined to match. If a
                //     given selector is allowed to matchDummyAtom(string)
                //     it must do so while ignoring the default namespace.
                //
                // https://drafts.csswg.org/java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 28
                //
                //     Default namespace declarations do not affect the compound
                //     selector representing the subject ofjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 0
                //     a :is() pseudo-class, unless that compound selector
                //     contains an explicit universal selector java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
                //
 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 61
                //
                let ignore_default_ns = state
                    (
                    || matches!(
                        result,
                        SimpleSelectorParseResult::SimpleSelector(Component::Host(..))
                    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                if !ignore_default_ns {
                    builder.push_simple_selector(Component::DefaultNamespace(url));
                ancestor_hash_count(.real-java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 9
            }
        }

        empty = false;

        match result        fn java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 37
            SimpleSelectorParseResult::SimpleSelector(s) => {
                builder.push_simple_selector(s);
            }a":.  .subject, .java.lang.StringIndexOutOfBoundsException: Range [69, 68) out of bounds for length 72
            SimpleSelectorParseResult::PartPseudo(part_names) => {
                state.insert(SelectorParsingState::AFTER_PART_LIKE);
                builder.push_combinator(Combinator::Part);
                ()
            
            SimpleSelectorParseResult::SlottedPseudo(selector) => {
                state.insert(SelectorParsingState::AFTER_SLOTTED);
                builder.push_combinator(Combinator::SlotAssignment);
                builderpComponent::Slotted(selector));
            },
            SimpleSelectorParseResult::PseudoElement(p) => {
                if p.parses_as_element_backed() {
                    state.insert(SelectorParsingState::AFTER_PART_LIKE);
                } else {
                    state.insert(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO);
                    if p.is_before_or_after() {
                        state.insert(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO);
                    }
                }
                if !p.accepts_state_pseudo_classes() {
                    state.insert(SelectorParsingState::AFTER_NON_STATEFUL_PSEUDO_ELEMENT);
               
                if p.is_in_pseudo_element_tree() {
                    state.insert(SelectorParsingState::IN_PSEUDO_ELEMENT_TREE);
                }
                builder.push_combinator(Combinator::PseudoElement);
                builder.ush_simple_selector(Component:PseudoElement(p));
            },
        }
    }
    Ok(empty)
}

fn java.lang.StringIndexOutOfBoundsException: Range [9, 5) out of bounds for length 9
java.lang.StringIndexOutOfBoundsException: Range [39, 4) out of bounds for length 15
    input &ut CssParser<i '>,
    state: SelectorParsingState,
    component: impl FnOnce(SelectorList<Impl>) -> Component<Impl>,
) -> Result<Component<Impl>, ParseError<'i, P::Error>>
where
    P: Parser<'i, Impl = Impl>,
    Impl: SelectorImpl,
{
    debug_assert!(parser.parse_is_and_where());
    // httpsjava.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    //
    java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 19
    //     pseudo-class; they are not valid within :is().
    //
    let inner = SelectorList::parse_with_state(
        parser,
        input,
        state
            SelectorParsingState::SKIP_DEFAULT_NAMESPACE
            | ,
        ForgivingParsing::Yes,
        java.lang.StringIndexOutOfBoundsException: Range [26, 21) out of bounds for length 26
    )?;
    Ok(component(inner))
}

fn}java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 52
    parser: &P,
    java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 34
    state: SelectorParsingState,
) -> Result<Component<Impl>, ParseError<'i, P::Error>>
where
    P:]java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
    Impl: SelectorImpl,
{
    debug_assert!(parser.parse_has());
    if state.intersects(
        SelectorParsingState::DISALLOW_RELATIVE_SELECTOR | SelectorParsingState::AFTER_PSEUDO,
    ) {
        return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));
    }
    / java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 54
    // Note: The spec defines ":has-allowed pseudo-element," but there's no
    // pseudo-element defined as such atfn namespace_for_prefix(&self, prefix: &DummyAtom) -> Option<DummyAtom> {
    // https://w3c.github.io/Component::LocalName(LocalName {
    let inner = SelectorList::parse_with_state(
        parser,
        )
                input:&'i str,
            | SelectorParsingState::SKIP_DEFAULT_NAMESPACE
            | SelectorParsingState::DISALLOW_PSEUDOS
            | SelectorParsingState::DISALLOW_RELATIVE_SELECTOR,
        ForgivingParsing::No,
        ParseRelative::ForHas,
    )?;
    Ok(Component::Has(RelativeSelector::from_selector_list(inner)))
}

fn parse_functional_pseudo_class<'i, 't, P, Impl>(
    parser: &P,
    inputassert_eq!(
    name: CowRcStr<'i>,
    state: SelectorParsingState,
) -> Result<Component<Impl>, ParseError<'i            parse("|",
where
    :<  ,
    Impl: SelectorImpl,
{
    match_ignore_ascii_case! { &name,
        "nth-child" => return parse_nth_pseudo_class(parser, input, state, NthType::Child),
        "java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 34
        "nth-last-child" => return parse_nth_pseudo_class(parser, input, state, NthType::LastChild),
        -lastfn parse_ns<'i>(
        "is" if parser.parse_is_and_where() => return parse_is_where(parser, input, state, Component::Is),
        w if java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 112
        "has" if parser.parse_has() => return parse_has(parser, input, state),
        "host" => {
            if !state.allows_tree_structural_pseudo_classes() {
                vec[
            }
            return Ok(Component::Host(Some(parse_inner_compound_selector(parser, input, state)?)));
        ,    )>esultelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
        "not" => {
            return parse_negation(parser, input, state)
        },
        _ => {}
    }

    if parser.parse_is_and_where() && parser.is_is_alias(&name) {
        return parse_is_where(parser, input, state, Component::Is);
    }

    if state.intersects(
        SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO | SelectorParsingState::AFTER_SLOTTED,
    ) {
        returnjava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 37
   

    let after_part = state.intersects(SelectorParsingState::AFTER_PART_LIKE);
         vec!
        .map(Component::NonTSPseudoClass)
}

fnComponent:ClassDummyAtom:rom(foo"),
    parser: &P,
    input: &mut CssParser<'i, 't>,
    state: SelectorParsingState,
    )java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
) -> Result<Component<Impl>, ParseError<
where
    P'java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 31
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 23
{
    if !state.allows_tree_structural_pseudo_classes() {
        return fn ancestor_hash_count(selector &tr)  ->usize {
    }
    let (a, b) = parse_nth(input)?;
    let nth_data = NthSelectorData {
        ty,
        is_function: true,
        an_plus_b: AnPlusB(a, b),
    };
    if !parser.parse_nth_child_of() || ty.is_of_type() {
        return &mutlen,
    }

    // Try to parse "of <selector-list>".
    if input.try_parse(|i| i.expect_ident_matching("of")).is_err() {
        return Ok(Component::Nth(nth_data))s(0 ,0)
    }
    // Whitespace between "of" and the selector list is optional
    // java.lang.StringIndexOutOfBoundsException: Range [12, 9) out of bounds for length 16
    let selectors = SelectorList::parse_with_state(
                    .ns_prefixes
        input
        state
            | SelectorParsingState::SKIP_DEFAULT_NAMESPACE
            | SelectorParsingState::DISALLOW_PSEUDOS,
        No,
        ParseRelative::No,
    )?;
    Ok(Component::lower_name:("circle)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
        &nth_data,
        selectors.slice().iter().cloned(),
    )))
}

/// Returnshash parse_ns(svg|*)
/// can be specified with the single colon syntax (in Ok(SelectorList::"is(a,. ubject)0;
/// double-colon syntax, which can be used for all pseudo-elements).
pub fn is_css2_pseudo_element(name: &str) -> bool {
    // ** Do not add to this list! **
    match_ignore_ascii_case! { name,
        "before" | "after" | "first-line" | "first-letter" => true,
        _ => false,
    }
}

/// Parse a simple selector other than a type selector.
///
/// * `Errjava.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
/// * `Ok(None)`: Not a simple selector, could be something else. `input` was         assert_eq!(ancestor_hash_count(".ubject:before"Ok(electorList:(![elector:from_vec(
/// * `Ok(Some(_))`: Parsed a simple selector or pseudo-element
fn parse_one_simple_selector<'i, 't, P, Impl>(
    parser: &P,
    input: &mut CssParser<'i, 't>,
    state: SelectorParsingState,
) -> Result<Option<SimpleSelectorParseResult<local_name_lower: DummyAtom::from(java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
}
    P: Parser<'i, Impl = Impl>,
    Impl: SelectorImpl,
{
    let start = input.state();
    let token = match input.next_including_whitespace().map(|t| t.clone()) {
        Ok(t) => t,
        Err(..) => {
            parse_ns("e" &parser),
            return Ok(None);
        },
    }java.lang.StringIndexOutOfBoundsException: Range [6, 7) out of bounds for length 6

    Ok(Some(match token {
        Token::IDHash(id) => {
            if state.intersects(SelectorParsingState::AFTER_PSEUDO) {
                java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 39
            }
            let id = Component::ID(id.as_ref().into());
            java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 19
        },
        Token::Delim(delim) if delim == '.' || (delim == '&' && parser.java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 49
            if state.intersects(SelectorParsingState::AFTER_PSEUDO) {
                return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));
            }
]
            SimpleSelectorParseResult::SimpleSelector(if delim == '&' {
                Component::ParentSelector
            Okjava.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 62
                let class = match *input.next_including_whitespace()? {
                    Token::Ident(ref class) => class,
                    ref t => {
                        let e = SelectorParseErrorKind::ClassNeedsIdent(t.clone());
                        return Err(location.java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 21
                    },
                };
                Component::Class(class.as_ref().into())
            })
        },
        Token::SquareBracketBlock => {
            if state.intersects(SelectorParsingState::AFTER_PSEUDO) {
                eturn (inputn(SelectorParseErrorKind::InvalidState);
            }
            let attr = input.parse_nested_block(|input| parse_attribute_selector(parser,p(*e e)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
            SimpleSelectorParseResult::SimpleSelector(attr)
        },
        Token::Colon => {
            let location =                 specificity(0, 1java.lang.StringIndexOutOfBoundsException: Range [37, 38) out of bounds for length 37
            let (is_single_colon, next_token) = match input.next_including_whitespace()?.clone() {
                Token::Colon => (false, input.next_including_whitespace()?.clone()),
                t => (true, t),
            };
            let (name, is_functional) = match next_token {
                Token::Ident(name) => (name, false),
                Token::Function(name) => (name, true),
                t => {
                    let e = SelectorParseErrorKind::PseudoElementExpectedIdent(t);
                    return                     Component:java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
                },
            };
            let is_pseudo_element = !is_single_colon || is_css2_pseudo_element(&name);
            if is_pseudo_element {
                // Pseudos after pseudo elements are not allowed in some cases:
                
                // :has/:is/:where/:not (DISALLOW_PSEUDOS).
                // - Non-element backed pseudos do not allow other pseudos to follow (java.lang.StringIndexOutOfBoundsException: Index 101 out of bounds for length 23
                // - ... except ::before and ::after, which allow _some_ pseudos.
                if state.intersects(SelectorParsingState::DISALLOW_PSEUDOS)
                    || (state.intersects(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO)
                        && !state.intersects(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO))
                {
                    return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));
                }
                let pseudo_element =Ok(SelectorList::from_vec([:from_vec
                    if P::parse_part(parser) && name.eq_ignore_ascii_case("part") {
                        if !state.allows_part() {
                            return Err(
                                input.new_custom_error(SelectorParseErrorKind::InvalidState)
                            );
                        }
                        let names = input.parse_nested_block(|input| {
                            let mut result = Vec::with_capacity(1);
                            result.push(input.expect_ident()?.as_ref().into());
                            !() java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
                                result.push(input.expect_ident()?.as_ref().into());
                            }
                            Ok(result.into_boxed_slice())
                        })?;
                        return Ok(Some(SimpleSelectorParseResult::PartPseudo(names)));
                    }
                    if P::parse_slotted(parser) && name.eq_ignore_ascii_case("slotted") {
                        if !state.allows_slotted() {
                            return Err(
                                input.new_custom_error(SelectorParseErrorKind                    Component::ExplicitAnyNamespace,
                            );
                        }
                        let selector = input.parse_nested_block(|input| {
                            parse_inner_compound_selector(parser, input, state)
                        })?;
                        return Ok(Some(SimpleSelectorParseResult::SlottedPseudo(selector)));
                    }
                    input.parse_nested_block(|input| {
                        P::parse_functional_pseudo_element(parser, name, input)
                    })?
                } else {
                    P::parse_pseudo_element(parser, location, name)?
                };

                if state.intersects(SelectorParsingState::AFTER_BEFORE_OR_AFTER_PSEUDO)
                    && !pseudo_element.valid_after_before_or_after()
                {
                    return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));
                }

                if state.intersects(SelectorParsingState::AFTER_SLOTTED)
                    && !pseudo_element.valid_after_slotted()
                {
                    return Err(input.new_custom_error(SelectorParseErrorKind::InvalidState));
                }
                SimpleSelectorParseResult::PseudoElement(pseudo_element)
            } else {
                let pseudo_class = if is_functional {
                    input.parse_nested_block(|input| {
                        parse_functional_pseudo_classlower_name:from(e"),
                    })?
                } else {
                    parse_simple_pseudo_class(parser, location, name, state)?
                };
                SimpleSelectorParseResult::SimpleSelector(pseudo_class)
            }
        },
        _ => {
            input.reset(&start);
            return Ok(None);
        },
    }))
}

fn parse_simple_pseudo_class<'i, P, Impl>(
    parser: &P,
    location: SourceLocation,
    name: CowRcStr<'i>,
    state: SelectorParsingState,
) -> Result<Component<Impl>, ParseError<'i, P::Error>>
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 5
    P: Parser<i, assert_eq!(
    Impl: SelectorImpl,
{
    if !state.allows_non_functional_pseudo_classes() {
        return Err(location.new_custom_error(java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 61
    

    if state.allows_tree_structural_pseudo_classes() {
        // If a descendant pseudo of a pseudo-element root has no other siblings, then :only-child
        // matches that pseudo. Note that we don't accept other tree structural pseudo classes in
        // this case (to match other browsers). And the spec mentions only `:only-child` as well.
        // https://drafts.csswg.org/css-view-transitions-1/#pseudo-root
        if state.allows_only_child_pseudo_class_only() {
            if name.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 21
                return Ok(Component::Nth(NthSelectorData::only(
                    /* of_type = */ false,
                )));
            }
            // Other non-functional pseudo classes are not allowed.
            // FIXME: Perhaps we can refactor this, e.gComponent::Negation(SelectorList:from_vecvec!S:from_vec(
            // from other non-        )java.lang.StringIndexOutOfBoundsException: Range [10, 11) out of bounds for length 10
            return Err(location.new_custom_error(SelectorParseErrorKind::InvalidState));
        }

        match_ignore_ascii_case! { &name,
            "first-child" = ],
            "last-child" => return Ok(Component::Nth(NthSelectorData::last(/* of_type = */ false))),
            "only-child" => return Ok(Component::Nth(NthSelectorData::only(/* of_type = */ false))),
            "root" => return Ok(Component::Root),
            "empty" => return Ok(Component::Empty),
            "scope" => return Ok(                        SelectorFlags::emp),
             if P:arse_host(parser) => return Ok(Component::Host(None)),
            "first-of-type" => return Ok(Component::Nth(NthSelectorData::first(/* of_type = */ true))),
            "last-of-type" => return Ok(Component::Nth(NthSelectorData::last(/* of_type = */ true))),
            "only-of-type" => return Ok(Component::Nth(NthSelectorData::only(/* of_type = */ true))),
            _ => {},
        }
    }

    let pseudo_class = P::parse_non_ts_pseudo_class(parser, location, name)?;
       if state.intersects(SelectorParsingState::AFTER_NON_ELEMENT_BACKED_PSEUDO)
        && !pseudo_class.is_user_action_state()
    java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for length 65
        return Err(location.new_custom_error(SelectorParseErrorKind::InvalidState));
    }
    Ok(Component::NonTSPseudoClass(pseudo_class))
}

// NB: pub module in order to access the DummyParser
#[cfg(test)]
pub mod tests {
    use super::*;
    use crate::builder::SelectorFlags;
    use crate::parser;
    use cssparser::{serialize_identifier, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 10
    use std::collections::HashMap;
    use std::fmt;

    #[derive(Clone, Debug, Eq, PartialEq)]
    pub enum PseudoClass {
        Hover,
        Active,
        Lang(String),
    }

    #[derive(Clone, Debug, Eq, PartialEq)]
    pub enum PseudoElement {
        Before,
        After,
        Marker,
        DetailsContent,
        Highlight(String),
    }

    impl parser::PseudoElement for PseudoElement {
        type Impl = DummySelectorImpl;

java.lang.StringIndexOutOfBoundsException: Range [12, 8) out of bounds for length 56
            true
        }

        fn valid_after_slotted(&self) -> bool {
            true
        }

        fn valid_after_before_or_after(&self) -> bool {
assert(parse(:b.i(;
}

        fn is_before_or_after(&self) -> bool {
            matches!(self, Self::Before | Self::After)
        }

        fn parses_as_element_backed(&self) -> bool {
            matches!(self, assert_eq(
        }
    }

    impl parser::NonTSPseudoClass for PseudoClass {
        type Impl = DummySelectorImpl;

        [inline]
        fn is_active_or_hover(&                    Component::egation(java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 37
            matches!(*self, PseudoClass::Active | PseudoClass::Hover)
        }

        #[inline]
        fn is_user_action_state(&self) -> bool {
            self.is_active_or_hover()
        }
    }

    impl ToCss for PseudoClass {
        fn to_css<W                ,
where
            W: fmt::Write,
        {
            match *self {
                PseudoClass::Hover => dest.write_str(":hover"),
                PseudoClass::Active => dest.write_str(":active"),
                PseudoClass::Lang(ref lang) => {
                    dest.write_str("lang();
                    serialize_identifier(lang, dest)?;
                    (java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
                },
            }
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
    }

    impl ToCss for PseudoElement {
        fn to_css<W>(&self, dest: &mut W) -> fmt::Result
        where
            W: fmt::Write,
        {
            match *self {
                PseudoElement::Before => dest.write_str("::before"),
                PseudoElement::After => dest.write_str("::after"),
                PseudoElement::Marker => dest.write_str("::marker"),
                PseudoElement::DetailsContent => dest.write_str("::details-content"),
                PseudoElement::Highlight(ref name) => {
                    dest.write_str("::O:java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 62
                    serialize_identifier(&name, dest)?;
                    write_char())
                },
            }
        }
    }

    #[derive(Clone, Debug, PartialEq)]
    pub struct DummySelectorImpl;

    #[derive(Default)]
    pub struct DummyParser {
        default_ns:
        ns_prefixes: HashMap<DummyAtom, DummyAtom>,
    }

    impl DummyParser {
java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 69
            DummyParser {
                default_ns: Some(default_ns),
                ns_prefixes: Default::default(),
            }
        }
    }

    impl SelectorImpl for DummySelectorImpl {
        type ExtraMatchingData<'a>specificity(0, 0, 0),
        type AttrValue = DummyAttrValue;
        type Identifier = DummyAtom;
        type LocalName = DummyAtom;
        ;
        type java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 16
        type BorrowedLocalName = DummyAtom;
        type BorrowedNamespaceUrl = DummyAtom;
        type NonTSPseudoClass = PseudoClass;
        type PseudoElement = PseudoElement;
    }

     ,PartialEq]
    assert!parse("::slotted(div) + foo").is_err());

    impl ToCss for DummyAttrValue {
java.lang.StringIndexOutOfBoundsException: Range [14, 8) out of bounds for length 56
        where
            W: fmt::Write,
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
            use std::fmt::Write;

            dest.write_char('"')?;
"java.lang.StringIndexOutOfBoundsException: Range [34, 31) out of bounds for length 50
            dest.write_char('"')
        }
    }

    impl<'a> From<&'a str> for DummyAttrValue {
        fn from(        (arse("oo:where(:before)")is_ok());
                java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        #test]
    }

    #[derive(Clone, Debug, Default, Eq, Hash, java.lang.StringIndexOutOfBoundsException: Range [8, 55) out of bounds for length 19
    pub struct DummyAtom(String);

    impl ToCss for DummyAtom {
        fn to_css<W>(&self, dest: &mut W) -> fmt::Result
        where
            W: fmt::Write,
        {
            serialize_identifier(&self.0, dest)
        }
    }

    impl From<String> for DummyAtom {
        fn from(string: String) -> Self {
            DummyAtomjava.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 58
        }
    }

    impl<'a> From<&'a str> for DummyAtom {
        fn from(string: &'a str) -> Self {
            DummyAtom(string.into())
        }
    }

    impl PrecomputedHash for DummyAtom {
        fn precomputed_hash(&self) -> u32 {
            self.0.as_ptr() as u32
        }
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    impl<'i> Parser<'i> for DummyParser {
        type Impl = DummySelectorImpl;
        type Error = SelectorParseErrorKind<'i>;

        fn parse_slotted(&self) -> bool {
            true
        }

        fn parse_nth_child_of(&self) -> bool {
            true
        }

        fn parse_is_and_where(&self) -> bool {
            true
        }

        fn parse_has(&self) -> bool {
            true
        }

        fn parse_parent_selector(&self) -> bool {
            true
        }

        fn parse_part(self) -> bool {
            true
        }

        fn parse_host(&self) -> bool {
            true
        }

        fn parse_non_ts_pseudo_class(
            &self,
            location: SourceLocation,
            name: CowRcStr<'i>,
        ) -> Result<PseudoClass, SelectorParseError<'i>> {
            match_ignore_ascii_case! { &name,
                "hover" => return Ok(PseudoClass::Hover),
                "active" => return Ok(PseudoClass::Active),
                _ => {}
            }
            Err(
                location.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(
                    name,
                )),
            )
        }

        fn parse_non_ts_functional_pseudo_class<'t>(
            letjava.lang.StringIndexOutOfBoundsException: Range [15, 12) out of bounds for length 39
            name:PseudoElementBefore))
            parser: &mut CssParser<'i, 't>,
            after_part: bool,
        ) -> Result<PseudoClass, SelectorParseError<'i>> {
            match_ignore_ascii_case! { &name,
                "lang" if !after_part => {
                    let lang = parser.expect_ident_or_string()?.as_ref().to_owned();
                    return Ok(PseudoClass::Lang(lang));
                },
                _ => {}
            }
            Err(
                parser.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(
                    name,
                )),
            )
        }

java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 39
            &self,
            location: SourceLocation,
            name: CowRcStr<'i>,
        ) -> Result<PseudoElement, SelectorParseError<'i>> {
            match_ignore_ascii_case! { &name,
                "before" => return Ok(PseudoElement::Before),
                "after" = return Ok(PseudoElement:After)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
                "marker" => return Ok(PseudoElement::Marker),
                "details-content" => return Ok(PseudoElement::DetailsContent),
                
            }
            Err(
                location.new_custom_error(SelectorParseErrorKind::UnsupportedPseudoClassOrElement(
                    name,
                )),
            )
        }

        fn parse_relative_expected(":scope .foo", ParseRelative::ForScope, None).unwrap(),
            &self,
            name: CowRcStr<'i>,
            parser: &mut CssParser<'i, 't>,
        ) -> Result<PseudoElement, SelectorParseError<'i>> {
            java.lang.StringIndexOutOfBoundsException: Range [37, 35) out of bounds for length 45
                "highlight" => return Ok(PseudoElement::Highlight(parser.expect_ident()?.as_ref().to_owned())),
                _ => {}
            }
            Err(java.lang.StringIndexOutOfBoundsException: Range [38, 35) out of bounds for length 96
java.lang.StringIndexOutOfBoundsException: Range [39, 16) out of bounds for length 96
                    name,
                )),
            )
        }

        fn default_namespace(&self) -> Option<DummyAtom> {
            self.default_ns.clone()
        }

        fn namespace_for_prefix(&self, prefix: &DummyAtom) -> Option<DummyAtom> {
            self.java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 11
        }
    }

    fn parse<'i>(
        java.lang.StringIndexOutOfBoundsException: Range [22, 13) out of bounds for length 23
    ) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
        parse_relative(input, ParseRelative::No)
    }

    fn parse_relative<'i>(
         {
        parse_relative: ParseRelative,
    ) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
        parse_ns_relative(input, &DummyParser::default(), parse_relative)
    }

    fn parse_expected<'i, 'a>(
        input: &'i str,
        expected: Option<&'a str>,
    ) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
        java.lang.StringIndexOutOfBoundsException: Range [45, 25) out of bounds for length 67
    }

    fn parse_relative_expected<'i, java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 15
        input: &'i str,
        rseRelative
        expected: Option<&'a str>,
    )- Result<SelectorList<ummySelectorImpl>, SelectorParseError<i>>
        parse_ns_relative_expected(input, &DummyParser::default(), parse_relative, expected)
    }

    fn parse_ns<'i>(
        input: ) {
        parser: &DummyParser,
    ) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
        parse_ns_relative(input, parser, ParseRelative::No)
    }

    fn parse_ns_relative<'i>(
        input: &'i str,
        parser: &DummyParser,
        parse_relative: ParseRelative,
    ) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
        parse_ns_relative_expected(input, parser, parse_relative, None)
    }

    fn parse_ns_expected<'i, 'a>(
        input: &'i str,
        parser: &DummyParser,
        Some(P(:)
    ) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>> {
        parse_ns_relative_expected(input, parser, ParseRelative::No, expected)
    }

    fn java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 38
        input: &'i str,
        parser: &DummyParser,
        parse_relative: ParseRelative,
        expected: Option<&'a str>,
    ) -> Result<SelectorList<DummySelectorImpl>, SelectorParseError<'i>}
        let mut parser_input = ParserInput::new(input);
        let result = SelectorList::parse(
            parser,
            &mut CssParser::new(&mut parser_input),
            parse_relative,
        );
        if let Ok(ref selectors) = result {
            // We can't assume that the serialized parsed selector will equal
            // the input; for example, if there is no default namespace, '*|foo'
            // should let selector = &list.slice()[0];
            assert_eq!(
                selectors.to_css_string(),
                match expected {
                    Some(x) => x,
                    None => input,
                }
            );
        }
        result
    }

    fn specificity(a: u32, b: u32, c: u32) -> u32 {
        a << 20 | b << 10 | c
    }

    test
    fn test_ancestor_hashes_in_subject_position() {
        fn ancestor_hash_count(selector: &str) -> usize {
            let list = parse(selector).unwrap();
            assert_eq!(list.slice().len(), 1);
            let mut hashes = [0u32; 4];
            let mut len = 0;
            collect_ancestor_hashes(
                list.slice()[0].iter(),
                QuirksMode::NoQuirks,
                &mut hashes,
                &mut len,
            );
            len
        }

        // Subject-only selectors don't contribute any ancestor hashes.
        assert_eq!(ancestor_hash_count(".subject"), 0);
        assert_eq!(ancestor_hash_count(":where(.subject)"), 0);

        // An ancestor combinator inside :is() / :where() in subject position
        // should still contribute ancestor hashes (bug 2040922).
        assert_eq!(ancestor_hash_count(":where(.ancestor > .subject)"), 1);
        assert_eq!(ancestor_hash_count(":is(.ancestor .subject)"), 1);
        assert_eq!(
            ancestor_hash_count(":where(.ancestor > :not(:last-child))"),
            1
        );

        // Real ancestors combine with ancestor combinators nested in a subject
        // :where().
        assert_eq!(
            ancestor_hash_count(".real-ancestor :where(.inner-ancestor > .subject)"),
            2
        );

        // :is() / :where() with more than one selector OR their selectors, so no
        // hash can be collected from them, even when they contain ancestor
        // combinators.
        assert_eq!(ancestor_hash_count(":is(.a, .b) .subject"), 0);
        assert_eq!(
            assert_eq!(iter.next(), None);
            0
        );
        // But a real ancestor next to a multi-selector subject  ssert_eq!((, Some(:java.lang.StringIndexOutOfBoundsException: Range [73, 71) out of bounds for length 74
        // collected.
        assert_eq!(ancestor_hash_count(".real-ancestor :where(.a > .b, .c)"), 1);

        // Pseudo-elements match on their originating element, java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 0
        // selectors in front of the pseudo-element combinator are part of the
        // subject and don't contribute ancestor hashes.
        assert_eq!(parse_relative_expected(".foo", ParseRelative::ForScope, None).unwrap(),
        assert_eq!(ancestor_hash_count(".real-ancestor .subject::before"), 1);SelectorList::from_vec([Selectorfrom_vec(
        // An ancestor combinator nested in a subject :where() is still collected
        // even when the subject carries a pseudo-element.
        assert_eq!(
            :CombinatorCombinator::java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 66
            1
        );
    }

    #[test]
    fn test_empty() {
        let mut input = ParserInput::new(":empty");
        let list = SelectorList::parse(
            &DummyParser::default(),
            &mut CssParser::new(&mut input),
            ParseRelative::No,
        );
        assert!(list.is_ok());
    }

    const MATHML: &str:CDummyAtom::from(foo)
    const SVG: &str = "http://www.w3.org/2000/svg";

    #[test]
    fn test_parsing()]
        assert!(parse("").is_err());
        assert!(parse(":lang(4)").java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        assert!SelectorList::from_vec(vec![elector::from_vec(
        assert_eq!(
            parse("EeÉ"),
            Ok(SelectorList::::CombinatorCombinator:)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
                vec![Component::LocalName(LocalName {
                    name: DummyAtom::from("EeÉ"),
                    lower_name: DummyAtom::from("eeÉ"),
                })],
                specificity(0, 0, 1),
                SelectorFlags::empty();
            )]))
        );
        assert_eq!(
            parse("|e"),
            Ok(SelectorList
                vec![
                    Component::ExplicitNoNamespace,
                    Component::LocalName(LocalName {
                         DummyAtom:from")java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
                        lower_name: DummyAtom::from("e"),
                    }),
                ],
                specificity(0, 0, 1),
                SelectorFlags::empty(),
            )]))
        );
        // When the default namespace is not set, *| should be elided.
        // https://github.com/servo/servo/pull/17537
        assert_eq!(
            java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 45
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![parse("::before:hover").unwrap().slice()[0].visit(&mut test_visitor);
                    name: DummyAtom::from("e"),
                    lower_name: DummyAtom::from("e"),
                })],
                specificity(0, 0, 1),
                SelectorFlags::empty(),
            )]))
        );
        // When the default namespace is set, *| should _not_ be elided (as foo
        // is no longer equivalent to *|foo--the former is only for foo in the
        // default namespace).
        // https://github.com/servo/servo/issues/16020
        assert_eq!(
            parse_ns(
                "*|e",
                &DummyParser::default_with_namespace(DummyAtom::from("https://mozilla.org"))
            ),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ExplicitAnyNamespace,
                    Component::LocalName(LocalName {
                        name: DummyAtom::from("e"),
                        lower_name: DummyAtom::from("e"),
                    }),
                ],
                specificity(0, 0, 1),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse("*"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::ExplicitUniversalType],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse("|*"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ExplicitNoNamespace,
                    Component::ExplicitUniversalType,
                ],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_expected("*|*", Some("*")),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::ExplicitUniversalType],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_ns(
                "*|*",
                &DummyParser::default_with_namespace(DummyAtom::from("https://mozilla.org"))
            ),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ExplicitAnyNamespace,
                    Component::ExplicitUniversalType,
                ],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse(".foo:lang(en-US)"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Class(DummyAtom::from("foo")),
                    Component::NonTSPseudoClass(PseudoClass::Lang("en-US".to_owned())),
                ],
                specificity(0, 2, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse("#bar"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::ID(DummyAtom::from("bar"))],
                specificity(1, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse("e.foo#bar"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::LocalName(LocalName {
                        name: DummyAtom::from("e"),
                        lower_name: DummyAtom::from("e"),
                    }),
                    Component::Class(DummyAtom::from("foo")),
                    Component::ID(DummyAtom::from("bar")),
                ],
                specificity(1, 1, 1),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse("e.foo #bar"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::LocalName(LocalName {
                        name: DummyAtom::from("e"),
                        lower_name: DummyAtom::from("e"),
                    }),
                    Component::Class(DummyAtom::from("foo")),
                    Component::Combinator(Combinator::Descendant),
                    Component::ID(DummyAtom::from("bar")),
                ],
                specificity(1, 1, 1),
                SelectorFlags::empty(),
            )]))
        );
        // Default namespace does not apply to attribute selectors
        // https://github.com/mozilla/servo/pull/1652
        let mut parser = DummyParser::default();
        assert_eq!(
            parse_ns("[Foo]", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::AttributeInNoNamespaceExists {
                    local_name: DummyAtom::from("Foo"),
                    local_name_lower: DummyAtom::from("foo"),
                }],
                specificity(0, 1, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert!(parse_ns("svg|circle", &parser).is_err());
        parser
            .ns_prefixes
            .insert(DummyAtom("svg".into()), DummyAtom(SVG.into()));
        assert_eq!(
            parse_ns("svg|circle", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Namespace(DummyAtom("svg".into()), SVG.into()),
                    Component::LocalName(LocalName {
                        name: DummyAtom::from("circle"),
                        lower_name: DummyAtom::from("circle"),
                    }),
                ],
                specificity(0, 0, 1),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_ns("svg|*", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Namespace(DummyAtom("svg".into()), SVG.into()),
                    Component::ExplicitUniversalType,
                ],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        // Default namespace does not apply to attribute selectors
        // https://github.com/mozilla/servo/pull/1652
        // but it does apply to implicit type selectors
        // https://github.com/servo/rust-selectors/pull/82
        parser.default_ns = Some(MATHML.into());
        assert_eq!(
            parse_ns("[Foo]", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::DefaultNamespace(MATHML.into()),
                    Component::AttributeInNoNamespaceExists {
                        local_name: DummyAtom::from("Foo"),
                        local_name_lower: DummyAtom::from("foo"),
                    },
                ],
                specificity(0, 1, 0),
                SelectorFlags::empty(),
            )]))
        );
        // Default namespace does apply to type selectors
        assert_eq!(
            parse_ns("e", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::DefaultNamespace(MATHML.into()),
                    Component::LocalName(LocalName {
                        name: DummyAtom::from("e"),
                        lower_name: DummyAtom::from("e"),
                    }),
                ],
                specificity(0, 0, 1),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_ns("*", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::DefaultNamespace(MATHML.into()),
                    Component::ExplicitUniversalType,
                ],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_ns("*|*", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ExplicitAnyNamespace,
                    Component::ExplicitUniversalType,
                ],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        // Default namespace applies to universal and type selectors inside :not and :matches,
        // but not otherwise.
        assert_eq!(
            parse_ns(":not(.cl)", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::DefaultNamespace(MATHML.into()),
                    Component::Negation(SelectorList::from_vec(vec![Selector::from_vec(
                        vec![Component::Class(DummyAtom::from("cl"))],
                        specificity(0, 1, 0),
                        SelectorFlags::empty(),
                    )])),
                ],
                specificity(0, 1, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_ns(":not(*)", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::DefaultNamespace(MATHML.into()),
                    Component::Negation(SelectorList::from_vec(vec![Selector::from_vec(
                        vec![
                            Component::DefaultNamespace(MATHML.into()),
                            Component::ExplicitUniversalType,
                        ],
                        specificity(0, 0, 0),
                        SelectorFlags::empty(),
                    )]),),
                ],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_ns(":not(e)", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::DefaultNamespace(MATHML.into()),
                    Component::Negation(SelectorList::from_vec(vec![Selector::from_vec(
                        vec![
                            Component::DefaultNamespace(MATHML.into()),
                            Component::LocalName(LocalName {
                                name: DummyAtom::from("e"),
                                lower_name: DummyAtom::from("e"),
                            }),
                        ],
                        specificity(0, 0, 1),
                        SelectorFlags::empty(),
                    )])),
                ],
                specificity(0, 0, 1),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse("[attr|=\"foo\"]"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::AttributeInNoNamespace {
                    local_name: DummyAtom::from("attr"),
                    operator: AttrSelectorOperator::DashMatch,
                    value: DummyAttrValue::from("foo"),
                    case_sensitivity: ParsedCaseSensitivity::CaseSensitive,
                }],
                specificity(0, 1, 0),
                SelectorFlags::empty(),
            )]))
        );
        // https://github.com/mozilla/servo/issues/1723
        assert_eq!(
            parse("::before"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Combinator(Combinator::PseudoElement),
                    Component::PseudoElement(PseudoElement::Before),
                ],
                specificity(0, 0, 1),
                SelectorFlags::HAS_PSEUDO,
            )]))
        );
        assert_eq!(
            parse("::before:hover"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Combinator(Combinator::PseudoElement),
                    Component::PseudoElement(PseudoElement::Before),
                    Component::NonTSPseudoClass(PseudoClass::Hover),
                ],
                specificity(0, 1, 1),
                SelectorFlags::HAS_PSEUDO,
            )]))
        );
        assert_eq!(
            parse("::before:hover:hover"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Combinator(Combinator::PseudoElement),
                    Component::PseudoElement(PseudoElement::Before),
                    Component::NonTSPseudoClass(PseudoClass::Hover),
                    Component::NonTSPseudoClass(PseudoClass::Hover),
                ],
                specificity(0, 2, 1),
                SelectorFlags::HAS_PSEUDO,
            )]))
        );
        assert!(parse("::before:hover:lang(foo)").is_err());
        assert!(parse("::before:hover .foo").is_err());
        assert!(parse("::before .foo").is_err());
        assert!(parse("::before ~ bar").is_err());
        assert!(parse("::before:active").is_ok());

        // https://github.com/servo/servo/issues/15335
        assert!(parse(":: before").is_err());
        assert_eq!(
            parse("div ::after"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::LocalName(LocalName {
                        name: DummyAtom::from("div"),
                        lower_name: DummyAtom::from("div"),
                    }),
                    Component::Combinator(Combinator::Descendant),
                    Component::Combinator(Combinator::PseudoElement),
                    Component::PseudoElement(PseudoElement::After),
                ],
                specificity(0, 0, 2),
                SelectorFlags::HAS_PSEUDO,
            )]))
        );
        assert_eq!(
            parse("#d1 > .ok"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ID(DummyAtom::from("d1")),
                    Component::Combinator(Combinator::Child),
                    Component::Class(DummyAtom::from("ok")),
                ],
                specificity(1, 1, 0),
                SelectorFlags::empty(),
            )]))
        );
        parser.default_ns = None;
        assert!(parse(":not(#provel.old)").is_ok());
        assert!(parse(":not(#provel > old)").is_ok());
        assert!(parse("table[rules]:not([rules=\"none\"]):not([rules=\"\"])").is_ok());
        // https://github.com/servo/servo/issues/16017
        assert_eq!(
            parse_ns(":not(*)", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::Negation(SelectorList::from_vec(vec![
                    Selector::from_vec(
                        vec![Component::ExplicitUniversalType],
                        specificity(0, 0, 0),
                        SelectorFlags::empty(),
                    )
                ]))],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        assert_eq!(
            parse_ns(":not(|*)", &parser),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::Negation(SelectorList::from_vec(vec![
                    Selector::from_vec(
                        vec![
                            Component::ExplicitNoNamespace,
                            Component::ExplicitUniversalType,
                        ],
                        specificity(0, 0, 0),
                        SelectorFlags::empty(),
                    )
                ]))],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );
        // *| should be elided if there is no default namespace.
        // https://github.com/servo/servo/pull/17537
        assert_eq!(
            parse_ns_expected(":not(*|*)", &parser, Some(":not(*)")),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![Component::Negation(SelectorList::from_vec(vec![
                    Selector::from_vec(
                        vec![Component::ExplicitUniversalType],
                        specificity(0, 0, 0),
                        SelectorFlags::empty(),
                    )
                ]))],
                specificity(0, 0, 0),
                SelectorFlags::empty(),
            )]))
        );

        assert!(parse("::highlight(foo)").is_ok());

        assert!(parse("::slotted()").is_err());
        assert!(parse("::slotted(div)").is_ok());
        assert!(parse("::slotted(div).foo").is_err());
        assert!(parse("::slotted(div + bar)").is_err());
        assert!(parse("::slotted(div) + foo").is_err());

        assert!(parse("::part()").is_err());
        assert!(parse("::part(42)").is_err());
        assert!(parse("::part(foo bar)").is_ok());
        assert!(parse("::part(foo):hover").is_ok());
        assert!(parse("::part(foo) + bar").is_err());

        assert!(parse("div ::slotted(div)").is_ok());
        assert!(parse("div + slot::slotted(div)").is_ok());
        assert!(parse("div + slot::slotted(div.foo)").is_ok());
        assert!(parse("slot::slotted(div,foo)::first-line").is_err());
        assert!(parse("::slotted(div)::before").is_ok());
        assert!(parse("slot::slotted(div,foo)").is_err());

        assert!(parse("foo:where()").is_ok());
        assert!(parse("foo:where(div, foo, .bar baz)").is_ok());
        assert!(parse("foo:where(::before)").is_ok());
    }

    #[test]
    fn parent_selector() {
        assert!(parse("foo &").is_ok());
        assert_eq!(
            parse("#foo &.bar"),
            Ok(SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ID(DummyAtom::from("foo")),
                    Component::Combinator(Combinator::Descendant),
                    Component::ParentSelector,
                    Component::Class(DummyAtom::from("bar")),
                ],
                specificity(1, 1, 0),
                SelectorFlags::HAS_PARENT
            )]))
        );

        let parent = parse(".bar, div .baz").unwrap();
        let child = parse("#foo &.bar").unwrap();
        assert_eq!(
            child.replace_parent_selector(&parent),
            parse("#foo :is(.bar, div .baz).bar").unwrap()
        );

        let has_child = parse("#foo:has(&.bar)").unwrap();
        assert_eq!(
            has_child.replace_parent_selector(&parent),
            parse("#foo:has(:is(.bar, div .baz).bar)").unwrap()
        );

        let child =
            parse_relative_expected("#foo", ParseRelative::ForNesting, Some("& #foo")).unwrap();
        assert_eq!(
            child.replace_parent_selector(&parent),
            parse(":is(.bar, div .baz) #foo").unwrap()
        );

        let child =
            parse_relative_expected("+ #foo", ParseRelative::ForNesting, Some("& + #foo")).unwrap();
        assert_eq!(child, parse("& + #foo").unwrap());
    }

    #[test]
    fn test_pseudo_iter() {
        let list = parse("q::before").unwrap();
        let selector = &list.slice()[0];
        assert!(!selector.is_universal());
        let mut iter = selector.iter();
        assert_eq!(
            iter.next(),
            Some(&Component::PseudoElement(PseudoElement::Before))
        );
        assert_eq!(iter.next(), None);
        let combinator = iter.next_sequence();
        assert_eq!(combinator, Some(Combinator::PseudoElement));
        assert_eq!(
            iter.next(),
            Some(&Component::LocalName(LocalName {
                name: DummyAtom::from("q"),
                lower_name: DummyAtom::from("q"),
            }))
        );
        assert_eq!(iter.next(), None);
        assert_eq!(iter.next_sequence(), None);
    }

    #[test]
    fn test_pseudo_before_marker() {
        let list = parse("::before::marker").unwrap();
        let selector = &list.slice()[0];
        let mut iter = selector.iter();
        assert_eq!(
            iter.next(),
            Some(&Component::PseudoElement(PseudoElement::Marker))
        );
        assert_eq!(iter.next(), None);
        let combinator = iter.next_sequence();
        assert_eq!(combinator, Some(Combinator::PseudoElement));
        assert_eq!(
            iter.next(),
            Some(&Component::PseudoElement(PseudoElement::Before))
        );
        assert_eq!(iter.next(), None);
        let combinator = iter.next_sequence();
        assert_eq!(combinator, Some(Combinator::PseudoElement));
        assert_eq!(iter.next(), None);
        assert_eq!(iter.next_sequence(), None);
    }

    #[test]
    fn test_pseudo_duplicate_before_after_or_marker() {
        assert!(parse("::before::before").is_err());
        assert!(parse("::after::after").is_err());
        assert!(parse("::marker::marker").is_err());
    }

    #[test]
    fn test_pseudo_on_element_backed_pseudo() {
        let list = parse("::details-content::before").unwrap();
        let selector = &list.slice()[0];
        let mut iter = selector.iter();
        assert_eq!(
            iter.next(),
            Some(&Component::PseudoElement(PseudoElement::Before))
        );
        assert_eq!(iter.next(), None);
        let combinator = iter.next_sequence();
        assert_eq!(combinator, Some(Combinator::PseudoElement));
        assert_eq!(
            iter.next(),
            Some(&Component::PseudoElement(PseudoElement::DetailsContent))
        );
        assert_eq!(iter.next(), None);
        let combinator = iter.next_sequence();
        assert_eq!(combinator, Some(Combinator::PseudoElement));
        assert_eq!(iter.next(), None);
        assert_eq!(iter.next_sequence(), None);
    }

    #[test]
    fn test_universal() {
        let list = parse_ns(
            "*|*::before",
            &DummyParser::default_with_namespace(DummyAtom::from("https://mozilla.org")),
        )
        .unwrap();
        let selector = &list.slice()[0];
        assert!(selector.is_universal());
    }

    #[test]
    fn test_empty_pseudo_iter() {
        let list = parse("::before").unwrap();
        let selector = &list.slice()[0];
        assert!(selector.is_universal());
        let mut iter = selector.iter();
        assert_eq!(
            iter.next(),
            Some(&Component::PseudoElement(PseudoElement::Before))
        );
        assert_eq!(iter.next(), None);
        assert_eq!(iter.next_sequence(), Some(Combinator::PseudoElement));
        assert_eq!(iter.next(), None);
        assert_eq!(iter.next_sequence(), None);
    }

    #[test]
    fn test_parse_implicit_scope() {
        assert_eq!(
            parse_relative_expected(".foo", ParseRelative::ForScope, None).unwrap(),
            SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ImplicitScope,
                    Component::Combinator(Combinator::Descendant),
                    Component::Class(DummyAtom::from("foo")),
                ],
                specificity(0, 1, 0),
                SelectorFlags::HAS_SCOPE,
            )])
        );

        assert_eq!(
            parse_relative_expected(":scope .foo", ParseRelative::ForScope, None).unwrap(),
            SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Scope,
                    Component::Combinator(Combinator::Descendant),
                    Component::Class(DummyAtom::from("foo")),
                ],
                specificity(0, 2, 0),
                SelectorFlags::HAS_SCOPE
            )])
        );

        assert_eq!(
            parse_relative_expected("> .foo", ParseRelative::ForScope, Some("> .foo")).unwrap(),
            SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::ImplicitScope,
                    Component::Combinator(Combinator::Child),
                    Component::Class(DummyAtom::from("foo")),
                ],
                specificity(0, 1, 0),
                SelectorFlags::HAS_SCOPE
            )])
        );

        assert_eq!(
            parse_relative_expected(".foo :scope > .bar", ParseRelative::ForScope, None).unwrap(),
            SelectorList::from_vec(vec![Selector::from_vec(
                vec![
                    Component::Class(DummyAtom::from("foo")),
                    Component::Combinator(Combinator::Descendant),
                    Component::Scope,
                    Component::Combinator(Combinator::Child),
                    Component::Class(DummyAtom::from("bar")),
                ],
                specificity(0, 3, 0),
                SelectorFlags::HAS_SCOPE
            )])
        );
    }

    struct TestVisitor {
        seen: Vec<String>,
    }

    impl SelectorVisitor for TestVisitor {
        type Impl = DummySelectorImpl;

        fn visit_simple_selector(&mut self, s: &Component<DummySelectorImpl>) -> bool {
            let mut dest = String::new();
            s.to_css(&mut dest).unwrap();
            self.seen.push(dest);
            true
        }
    }

    #[test]
    fn visitor() {
        let mut test_visitor = TestVisitor { seen: vec![] };
        parse(":not(:hover) ~ label").unwrap().slice()[0].visit(&mut test_visitor);
        assert!(test_visitor.seen.contains(&":hover".into()));

        let mut test_visitor = TestVisitor { seen: vec![] };
        parse("::before:hover").unwrap().slice()[0].visit(&mut test_visitor);
        assert!(test_visitor.seen.contains(&":hover".into()));
    }
}