Selectors Level 4

Editor’s Draft,

This version:
https://drafts.csswg.org/selectors
Latest published version:
https://www.w3.org/TR/selectors4/
Previous Versions:
https://www.w3.org/TR/2013/WD-selectors4-20130502/
https://www.w3.org/TR/2012/WD-selectors4-20120823/
https://www.w3.org/TR/2011/WD-selectors4-20110929/
Test Suite:
http://test.csswg.org/suites/selectors-4_dev/nightly-unstable/
Issue Tracking:
Inline In Spec
GitHub Issues
Editors:
Elika J. Etemad / fantasai (Invited Expert)
Tab Atkins Jr. (Google)
Former Editors:
Tantek Çelik
Daniel Glazman
Ian Hickson
Peter Linss
John Williams

Abstract

Selectors are patterns that match against elements in a tree, and as such form one of several technologies that can be used to select nodes in a document. Selectors have been optimized for use with HTML and XML, and are designed to be usable in performance-critical code. They are a core component of CSS (Cascading Style Sheets), which uses Selectors to bind style properties to elements in the document. Selectors Level 4 describes the selectors that already exist in [SELECT], and further introduces new selectors for CSS and other languages that may need them.

CSS is a language for describing the rendering of structured documents (such as HTML and XML) on screen, on paper, in speech, etc.

Status of this document

This is a public copy of the editors’ draft. It is provided for discussion only and may change at any moment. Its publication here does not imply endorsement of its contents by W3C. Don’t cite this document other than as work in progress.

GitHub Issues are preferred for discussion of this specification. When filing an issue, please put the text “selectors” in the title, preferably like this: “[selectors] …summary of comment…”. All issues and comments are archived, and there is also a historical archive.

This document was produced by the CSS Working Group (part of the Style Activity).

This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.

This document is governed by the 1 September 2015 W3C Process Document.

The following features are at-risk, and may be dropped during the CR period:

“At-risk” is a W3C Process term-of-art, and does not necessarily imply that the feature is in danger of being dropped or delayed. It means that the WG believes the feature may have difficulty being interoperably implemented in a timely manner, and marking it as such allows the WG to drop the feature if necessary when transitioning to the Proposed Rec stage, without having to publish a new Candidate Rec without the feature first.

1. Introduction

This section is not normative.

A selector is a boolean predicate that takes an element in a tree structure and tests whether the element matches the selector or not.

These expressions may be used for many things:

Selectors Levels 1, 2, and 3 are defined as the subsets of selector functionality defined in the CSS1, CSS2.1, and Selectors Level 3 specifications, respectively. This module defines Selectors Level 4.

1.1. Module Interactions

This module replaces the definitions of and extends the set of selectors defined for CSS in [SELECT] and [CSS21].

Pseudo-element selectors, which define abstract elements in a rendering tree, are not part of this specification: their generic syntax is described here, but, due to their close integration with the rendering model and irrelevance to other uses such as DOM queries, they will be defined in other modules.

2. Selectors Overview

This section is non-normative, as it merely summarizes the following sections.

A selector represents a structure. This structure can be used as a condition (e.g. in a CSS rule) that determines which elements a selector matches in the document tree, or as a flat description of the HTML or XML fragment corresponding to that structure.

Selectors may range from simple element names to rich contextual representations.

The following table summarizes the Selector syntax:

Pattern Represents Section Level
* any element §5.2 Universal selector 2
E an element of type E §5.1 Type (tag name) selector 1
E:not(s1, s2) an E element that does not match either compound selector s1 or compound selector s2 §4.3 The Negation Pseudo-class: :not() 3/4
E:matches(s1, s2) an E element that matches compound selector s1 and/or compound selector s2 §4.2 The Matches-any Pseudo-class: :matches() 4
E:has(rs1, rs2) an E element, if either of the relative selectors rs1 or rs2, when evaluated with E as the :scope elements, match an element §4.4 The Relational Pseudo-class: :has() 4
E.warning an E element belonging to the class warning (the document language specifies how class is determined). §6.6 Class selectors 1
E#myid an E element with ID equal to myid. §6.7 ID selectors 1
E[foo] an E element with a foo attribute §6 Attribute selectors 2
E[foo="bar"] an E element whose foo attribute value is exactly equal to bar §6 Attribute selectors 2
E[foo="bar" i] an E element whose foo attribute value is exactly equal to any (ASCII-range) case-permutation of bar §6.3 Case-sensitivity 4
E[foo~="bar"] an E element whose foo attribute value is a list of whitespace-separated values, one of which is exactly equal to bar §6 Attribute selectors 2
E[foo^="bar"] an E element whose foo attribute value begins exactly with the string bar §6.2 Substring matching attribute selectors 3
E[foo$="bar"] an E element whose foo attribute value ends exactly with the string bar §6.2 Substring matching attribute selectors 3
E[foo*="bar"] an E element whose foo attribute value contains the substring bar §6.2 Substring matching attribute selectors 3
E[foo|="en"] an E element whose foo attribute value is a hyphen-separated list of values beginning with en §6 Attribute selectors 2
E:dir(ltr) an element of type E in with left-to-right directionality (the document language specifies how directionality is determined) §7.1 The Directionality Pseudo-class: :dir() 4
E:lang(zh, "*-hant") an element of type E tagged as being either in Chinese (any dialect or writing system) or othewise written with traditional Chinese characters §7.2 The Language Pseudo-class: :lang() 2/4
E:any-link an E element being the source anchor of a hyperlink §8.1 The Hyperlink Pseudo-class: :any-link 4
E:link an E element being the source anchor of a hyperlink of which the target is not yet visited §8.2 The Link History Pseudo-classes: :link and :visited 1
E:visited an E element being the source anchor of a hyperlink of which the target is already visited §8.2 The Link History Pseudo-classes: :link and :visited 1
E:target an E element being the target of the referring URL §8.3 The Target Pseudo-class: :target 3
E:scope an E element being a designated reference element §8.4 The Reference Element Pseudo-class: :scope 4
E:current an E element that is currently presented in a time-dimensional canvas §10 Time-dimensional Pseudo-classes 4
E:current(s) an E element that is the deepest :current element that matches selector s §10 Time-dimensional Pseudo-classes 4
E:past an E element that is in the past in a time-dimensional canvas §10 Time-dimensional Pseudo-classes 4
E:future an E element that is in the future in a time-dimensional canvas §10 Time-dimensional Pseudo-classes 4
E:active an E element that is in an activated state §9 User Action Pseudo-classes 1
E:hover an E element that is under the cursor, or that has a descendant under the cursor §9 User Action Pseudo-classes 2
E:focus an E element that has user input focus §9 User Action Pseudo-classes 2
E:focus-ring an E element that has user input focus, and the UA has determined that a focus ring or other indicator should be drawn for that element §9 User Action Pseudo-classes 4
E:drop an E element that can possibly receive a drop §9.6 The Drag-and-Drop Pseudo-class: :drop and :drop() 4
E:drop(active) an E element that is the current drop target for the item being dragged §9.6 The Drag-and-Drop Pseudo-class: :drop and :drop() 4
E:drop(valid) an E element that could receive the item currently being dragged §9.6 The Drag-and-Drop Pseudo-class: :drop and :drop() 4
E:drop(invalid) an E element that cannot receive the item currently being dragged, but could receive some other item §9.6 The Drag-and-Drop Pseudo-class: :drop and :drop() 4
E:enabled
E:disabled
a user interface element E that is enabled or disabled, respectively §12.1.1 The :enabled and :disabled Pseudo-classes 3
E:read-write
E:read-only
a user interface element E that is user alterable, or not §12.1.2 The Mutability Pseudo-classes: :read-only and :read-write 3-UI/4
E:placeholder-shown an input control currently showing placeholder text §12.1.2 The Mutability Pseudo-classes: :read-only and :read-write 3-UI/4
E:default a user interface element E that is the default item in a group of related choices §12.1.4 The Default-option Pseudo-class: :default 3-UI/4
E:checked a user interface element E that is checked/selected (for instance a radio-button or checkbox) §12.2.1 The Selected-option Pseudo-class: :checked 3
E:indeterminate a user interface element E that is in an indeterminate state (neither checked nor unchecked) §12.2.2 The Indeterminate-value Pseudo-class: :indeterminate 4
E:valid
E:invalid
a user-input element E that meets, or doesn’t, its data validity semantics §12.3.2 The Range Pseudo-classes: :in-range and :out-of-range 3-UI/4
E:in-range
E:out-of-range
a user-input element E whose value is in-range/out-of-range §12.3.2 The Range Pseudo-classes: :in-range and :out-of-range 3-UI/4
E:required
E:optional
a user-input element E that requires/does not require input §12.3.3 The Optionality Pseudo-classes: :required and :optional 3-UI/4
E:user-error a user-altered user-input element E with incorrect input (invalid, out-of-range, omitted-but-required) §12.3.4 The User-interaction Pseudo-class: :user-invalid 4
E:root an E element, root of the document §13 Tree-Structural pseudo-classes 3
E:empty an E element that has no children (not even text nodes) §13 Tree-Structural pseudo-classes 3
E:blank an E element that has no content except maybe white space §13 Tree-Structural pseudo-classes 4
E:nth-child(n [of S]?) an E element, the n-th child of its parent matching S §13.4 Child-indexed Pseudo-classes 3
E:nth-last-child(n [of S]?) an E element, the n-th child of its parent matching S, counting from the last one §13.4 Child-indexed Pseudo-classes 3
E:first-child an E element, first child of its parent §13.4 Child-indexed Pseudo-classes 2
E:last-child an E element, last child of its parent §13.4 Child-indexed Pseudo-classes 3
E:only-child an E element, only child of its parent §13.4 Child-indexed Pseudo-classes 3
E:nth-of-type(n) an E element, the n-th sibling of its type §13.5 Typed Child-indexed Pseudo-classes 3
E:nth-last-of-type(n) an E element, the n-th sibling of its type, counting from the last one §13.5 Typed Child-indexed Pseudo-classes 3
E:first-of-type an E element, first sibling of its type §13.5 Typed Child-indexed Pseudo-classes 3
E:last-of-type an E element, last sibling of its type §13.5 Typed Child-indexed Pseudo-classes 3
E:only-of-type an E element, only sibling of its type §13.5 Typed Child-indexed Pseudo-classes 3
E F or E >> F an F element descendant of an E element §14.1 Descendant combinator ( ) or (>>) 1 or 4
E > F an F element child of an E element §14.2 Child combinator (>) 2
E + F an F element immediately preceded by an E element §14.3 Next-sibling combinator (+) 2
E ~ F an F element preceded by an E element §14.4 Following-sibling combinator (~) 3
F || E an E element that represents a cell in a grid/table belonging to a column represented by an element F §15 Grid-Structural Selectors 4
E:nth-column(n) an E element that represents a cell belonging to the nth column in a grid/table §15 Grid-Structural Selectors 4
E:nth-last-column(n) an E element that represents a cell belonging to the nth column in a grid/table, counting from the last one §15 Grid-Structural Selectors 4

Note: Some Level 4 selectors (noted above as "3-UI") were introduced in [CSS3UI].

2.1. Dynamic vs Static Selector Profiles

Selectors are used in many different contexts, with wildly varying performance characteristics. Some powerful selectors are unfortunately too slow to realistically include in the more performance-sensitive contexts. To accommodate this, two profiles of the Selectors spec are defined:

dynamic profile
The dynamic profile is appropriate for use in any context, including dynamic browser CSS selector matching. It includes every selector defined in this document, except for:
static profile
The static profile is appropriate for contexts which aren’t extremely performance sensitive; in particular, it’s appropriate for contexts which evaluate selectors against a static document tree. For example, the query() method defined in [DOM] should use the static profile. It includes all of the selectors defined in this document.

CSS implementations conformant to Selectors Level 4 must use the dynamic profile for CSS selection. Implementations using the dynamic profile must treat selectors that are not included in the profile as unknown and invalid.

The categorization of things into the "dynamic" or "static" profiles needs implementor review. If some things currently not in the dynamic profile can reasonably be done in CSS Selectors, we should move them.

3. Selector Syntax and Structure

3.1. Structure and Terminology

The term selector can refer to a simple selector, compound selector, complex selector, or selector list.

A simple selector represents an element matched by a particular aspect. A type selector, universal selector, attribute selector, class selector, ID selector, or pseudo-class is a simple selector.

A compound selector is a sequence of simple selectors that are not separated by a combinator. It represents an element that matches all of the simple selectors it contains. If it contains a type selector or universal selector, that selector must come first in the sequence. Only one type selector or universal selector is allowed in the sequence.

Note: As whitespace is a valid combinator, no whitespace is allowed between the simple selectors in a compound selector.

A complex selector is a sequence of one or more compound selectors separated by combinators.

A combinator represents a particular kind of relationship between the elements matched by the compound selectors on either side. Combinators in Selectors level 4 include: the descendant combinator (white space), the child combinator (U+003E, >), the next-sibling combinator (U+002B, +), and the following-sibling combinator (U+007E, ~).

A list of simple/compound/complex selectors is a comma-separated list of simple, compound, or complex selectors. This is also called just a selector list when the type is either unimportant or specified in the surrounding prose; if the type is important and unspecified, it defaults to meaning a list of complex selectors. See §4.1 Selector Lists for further details on selector lists.

The subject of a selector is the element(s) that selector is defined to be about:

An element is said to match a selector if it is a subject of that selector. Thus a selector consisting of a single compound selector matches any element satisfying its requirements. Prepending another compound selector and a combinator to a sequence imposes additional matching constraints, so the subjects of a complex selector are always a subset of the elements represented by its last compound selector.

Can we make this less wishy-washy by saying that a complex selector “represents” its last compound selector? Or do we need to have a + b “represent” both an "a" and a "b" in a sibling relationship?

Pseudo-elements aren’t handled here, and should be.

3.2. Data Model

Selectors are evaluated against an element tree such as the DOM. [DOM] Within this specification, this may be referred to as the "document tree" or "source document".

Each element may have any of the following five aspects, which can be selected against, all of which are matched as strings:

While individual elements may lack any of the above features, some elements are 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 match a featureless element, it must do so while ignoring the default namespace. [CSS3NAMESPACE]

For example, the shadow host in a shadow tree is featureless, and can’t be matched by any pseudo-class except for :host and :host-context().)

Many of the selectors depend on the semantics of the document language (i.e. the language and semantics of the document tree) and/or the semantics of the host language (i.e. the language that is using selectors syntax). For example, the :lang() selector depends on the document language (e.g. HTML) to define how an element is associated with a language. As a slightly different example, the ::first-line pseudo-element depends on the host language (e.g. CSS) to define what a ::first-line pseudo-element represents and what it can do.

3.3. Scoped Selectors

Some host applications may choose to scope selectors to a particular subtree or fragment of the document. The root of the scoping subtree is called the scoping root, and may be either a true element (the scoping element) or a virtual one (such as a DocumentFragment).

When a selector is scoped, it matches an element only if the element is a descendant of the scoping root. (The rest of the selector can match unrestricted; it’s only the final matched elements that must be within the scope.)

For example, the element.querySelector() function defined in [DOM] allows the author to evalute a scoped selector relative to the element it’s called on.

A call like widget.querySelector("a") will thus only find a elements inside of the widget element, ignoring any other as that might be scattered throughout the document.

Note: If the context does not explicitly define any :scope elements for the selector, the scoping root is a :scope element.

3.4. Relative Selectors

Certain contexts may accept relative selectors, which are a shorthand for selectors that represent elements relative to a :scope element (i.e. an element that matches :scope). In a relative selector, “:scope ” (the :scope pseudo-class followed by a space) is implied at the beginning of each complex selector that does not already contain the :scope pseudo-class. This allows the selector to begin syntactically with a combinator. However, it must be absolutized before matching.

Relative selectors, once absolutized, can additionally be scoped.

3.4.1. Absolutizing a Relative Selector

To absolutize a relative selector:

If there are no :scope elements and the selector is scoped to a virtual scoping root:

  1. If the selector starts with a child combinator, remove the child combinator. The selector is now absolute, with the additional constraint that the first compound selector in the selector only matches elements without a parent.
  2. Otherwise, if the selector starts with any combinator other than the white space form of the descendant combinator, change the selector to :not(*). This is the shortest selector that is valid, but guaranteed to match nothing.
  3. Otherwise, the selector is already absolute.

Otherwise:

  1. If the selector starts with a combinator other than the white space form of the descendant combinator, prepend :scope as the initial compound selector.
  2. Otherwise, if the selector does not contain any instance of the :scope pseudo-class (either at the top-level or as an argument to a functional pseudo-class), prepend :scope followed by the white space form of the descendant combinator.
  3. Otherwise, the selector is already absolute.

To absolutize a relative selector list, absolutize each relative selector in the list.

3.5. Pseudo-classes

Pseudo-classes are simple selectors that permit selection based on information that lies outside of the document tree or that can be awkward or impossible to express using the other simple selectors. They can also be dynamic, in the sense that an element can acquire or lose a pseudo-class while a user interacts with the document, without the document itself changing. Pseudo-classes do not appear in or modify the document source or document tree.

The syntax of a pseudo-class consists of a ":" (U+003A COLON) followed by the name of the pseudo-class as a CSS identifier, and, in the case of a functional pseudo-class, a pair of parentheses containing its arguments.

For example, :valid is a regular pseudo-class, and :lang() is a functional pseudo-class.

Like all CSS keywords, pseudo-class names are ASCII case-insensitive. No white space is allowed between the colon and the name of the pseudo-class, nor, as usual for CSS syntax, between a functional pseudo-class’s name and its opening parenthesis (which thus form a CSS function token). Also as usual, white space is allowed around the arguments inside the parentheses of a functional pseudo-class unless otherwise specified.

Like other simple selectors, pseudo-classes are allowed in all compound selectors contained in a selector, and must follow the type selector or universal selector, if present.

Note: Some pseudo-classes are mutually exclusive (such that a compound selector containing them, while valid, will never match anything), while others can apply simultaneously to the same element.

3.6. Pseudo-elements

Similar to how certain pseudo-classes represent additional state information not directly present in the document tree, a pseudo-element represents an element not directly present in the document tree. They are used to create abstractions about the document tree beyond those provided by the document tree. For example, pseudo-elements can be used to select portions of the document that do not correspond to a document-language element (including such ranges as don’t align to element boundaries or fit within its tree structure); that represent content not in the document tree or in an alternate projection of the document tree; or that rely on information provided by styling, layout, user interaction, and other processes that are not reflected in the document tree.

For instance, document languages do not offer mechanisms to access the first letter or first line of an element’s content, but there exist pseudo-elements (::first-letter and ::first-line) that allow those things to be styled. Notice especially that in the case of ::first-line, which portion of content is represented by the pseudo-element depends on layout information that cannot be inferred from the document tree.

Pseudo-elements can also represent content that doesn’t exist in the source document at all, such as the ::before and ::after pseudo-elements which allow additional content to be inserted before or after the contents of any element.

Like pseudo-classes pseudo-elements do not appear in or modify the document source or document tree. Accordingly, they also do not affect the interpretation of structural pseudo-classes or other selectors pertaining to their originating element or its tree.

The host language defines which pseudo-elements exist, their type, and their abilities. Pseudo-elements that exist in CSS are defined in [CSS21] (Level 2), [SELECT] (Level 3), and [CSS-PSEUDO-4] (Level 4).

3.6.1. Syntax

The syntax of a pseudo-element is "::" (two U+003A COLON characters) followed by the name of the pseudo-element as an identifier. Pseudo-element names are ASCII case-insensitive. No white space is allowed between the two colons, or between the colons and the name.

Because CSS Level 1 and CSS Level 2 conflated pseudo-elements and pseudo-classes by sharing a single-colon syntax for both, user agents must also accept the previous one-colon notation for the Level 1 & 2 pseudo-elements (::before, ::after, ::first-line, and ::first-letter). This compatibility notation is not allowed any other pseudo-elements. However, as this syntax is deprecated, authors should use the Level 3+ double-colon syntax for these pseudo-elements.

Pseudo-elements are featureless, and so can’t be matched by any other selector.

3.6.2. Binding to the Document Tree

Pseudo-elements do not exist independently in the tree: they are always bound to another element on the page, called their originating element. Syntactically, a pseudo-element immediately follows the compound selector representing its originating element. If this compound selector is omitted, it is assumed to be the universal selector *.

For example, in the selector div a::before, the a elements matched by the selector are the originating elements for the ::before pseudo-elements attached to them.

The selector ::first-line is equivalent to *::first-line, which selects the ::first-line pseudo-element on every element in the document.

When a pseudo-element is encountered in a selector, the part of the selector before the pseudo-element selects the originating element for the pseudo-element; the part of the selector after it, if any, applies to the pseudo-element itself. (See below.)

3.6.3. Pseudo-classing Pseudo-elements

A pseudo-element may be immediately followed by any combination of the user action pseudo-classes, in which case the pseudo-element is represented only when it is in the corresponding state. Whether these pseudo-classes can match on the pseudo-element depends on the pseudo-class and pseudo-element”s definitions: unless otherwise-specified, none of these pseudo-classes will match on the pseudo-element.

Clarify that :not() and :matches() can be used when containing abovementioned pseudos.

For example, since the :hover pseudo-class specifies that it can apply to any pseudo-element, ::first-line:hover will match when the first line is hovered. However, since neither :focus nor ::first-line define that :focus can apply to ::first-line, the selector ::first-line:focus will never match anything.

Does ::first-line:not(:focus) match anything?

Notice that ::first-line:hover is is very different from :hover::first-line, which matches the first line of any originating element that is hovered! For example, :hover::first-line also matches the first line of a paragraph when the second line of the paragraph is hovered, whereas ::first-line:hover only matches if the first line itself is hovered.

Note: Note that, unless otherwise specified in a future specification, pseudo-classes other than the user action pseudo-classes are not valid when compounded to a pseudo-element; so, for example, ::before:first-child is an invalid selector.

3.6.4. Internal Structure

Some pseudo-elements are defined to have internal structure. These pseudo-elements may be followed by child/descendant combinators to express those relationships. Selectors containing combinators after the pseudo-element are otherwise invalid.

For example, ::first-letter + span and ::first-letter em are invalid selectors. However, since ::shadow is defined to have internal structure, ::shadow > p is a valid selector.

Note: A future specification may expand the capabilities of existing pseudo-elements, so some of these currently-invalid selectors (e.g. ::first-line :any-link) may become valid in the future.

The children of such pseudo-elements can simultaneously be children of other elements, too, turning the selector match list into a directed acyclic graph. However, at least in CSS, their rendering must be defined so as to maintain the tree-ness of the box tree.

For example, the ::content pseudo-element treats elements distributed to it as its children. This means that, given the following fragment:
<div>
  <span>foo</span>
  <"shadow root">
    <content></content>
  </"shadow root">
</div>

the selectors div > span and div::shadow ::content > span select the same element via different paths.

However, when rendered, the <span> element generates boxes as if it were the child of the <content> element, rather than the <div> element, so the tree structure of the box tree is maintained.

3.7. Characters and case sensitivity

All Selectors syntax is case-insensitive within the ASCII range (i.e. [a-z] and [A-Z] are equivalent), except for the following parts, which are not under the control of Selectors: the case-sensitivity of document language element names, attribute names, and attribute values depends on the document language.

For example, in HTML, element and attribute names are ASCII case-insensitive, but in XML, they are case-sensitive.

Case sensitivity of namespace prefixes is defined in [CSS3NAMESPACE]. Case sensitivity of language ranges is defined in the :lang() section.

White space in Selectors consists of the code points SPACE (U+0020), TAB (U+0009), LINE FEED (U+000A), CARRIAGE RETURN (U+000D), and FORM FEED (U+000C) can occur in whitespace. Other space-like code points, such as EM SPACE (U+2003) and IDEOGRAPHIC SPACE (U+3000), are never part of white space.

Code points in Selectors can be escaped with a backslash according to the same escaping rules as CSS. [CSS21] Note that escaping a code point "cancels out" any special meaning it may have in Selectors. For example, the selector #foo>a contains a combinator, but #foo\>a instead selects an element with the id foo>a.

3.8. Declaring Namespace Prefixes

Certain selectors support namespace prefixes. The mechanism by which namespace prefixes are declared should be specified by the language that uses Selectors. If the language does not specify a namespace prefix declaration mechanism, then no prefixes are declared. In CSS, namespace prefixes are declared with the @namespacerule. [CSS3NAMESPACE]

3.9. Invalid Selectors and Error Handling

User agents must observe the rules for handling invalid selectors:

An invalid selector represents, and therefore matches, nothing.

4. Logical Combinations

4.1. Selector Lists

A comma-separated list of selectors represents the union of all elements selected by each of the individual selectors in the selector list. (A comma is U+002C.) For example, in CSS when several selectors share the same declarations, they may be grouped into a comma-separated list. White space may appear before and/or after the comma.

CSS example: In this example, we condense three rules with identical declarations into one. Thus,
h1 { font-family: sans-serif }
h2 { font-family: sans-serif }
h3 { font-family: sans-serif }

is equivalent to:

h1, h2, h3 { font-family: sans-serif }

Warning: the equivalence is true in this example because all the selectors are valid selectors. If just one of these selectors were invalid, the entire selector list would be invalid. This would invalidate the rule for all three heading elements, whereas in the former case only one of the three individual heading rules would be invalidated.

Invalid CSS example:
h1 { font-family: sans-serif }
h2..foo { font-family: sans-serif }
h3 { font-family: sans-serif }

is not equivalent to:

h1, h2..foo, h3 { font-family: sans-serif } 

because the above selector (h1, h2..foo, h3) is entirely invalid and the entire style rule is dropped. (When the selectors are not grouped, only the rule for h2..foo is dropped.)

4.2. The Matches-any Pseudo-class: :matches()

The matches-any pseudo-class, :matches(), is a functional pseudo-class taking a selector list as its argument. It represents an element that is represented by its argument.

Pseudo-elements cannot be represented by the matches-any pseudo-class; they are not valid within :matches().

Default namespace declarations do not affect the compound selector representing the subject of any selector within a :matches() pseudo-class, unless that compound selector contains an explicit universal selector or type selector.

For example, the following selector matches any element that is being hovered or focused, regardless of its namespace. In particular, it is not limited to only matching elements in the default namespace that are being hovered or focused.
*|*:matches(:hover, :focus) 

The following selector, however, represents only hovered or focused elements that are in the default namespace, because it uses an explicit universal selector within the :matches() notation:

*|*:matches(*:hover, *:focus) 

4.3. The Negation Pseudo-class: :not()

The negation pseudo-class, :not(), is a functional pseudo-class taking a selector list as an argument. It represents an element that is not represented by its argument.

Note: In Selectors Level 3, only a single simple selector was allowed as the argument to :not().

Pseudo-elements cannot be represented by the negation pseudo-class; they are not valid within :not().

For example, the following selector matches all button elements in an HTML document that are not disabled.
button:not([DISABLED]) 

The following selector represents all but FOO elements.

*:not(FOO)

The following compound selector represents all HTML elements except links.

html|*:not(:link):not(:visited)

As with :matches(), default namespace declarations do not affect the compound selector representing the subject of any selector within a :not() pseudo-class, unless that compound selector contains an explicit universal selector or type selector. (See :matches() for examples.)

Note: The :not() pseudo-class allows useless selectors to be written. For instance :not(*|*), which represents no element at all, or div:not(span), which is equivalent to div but with a higher specificity.

4.4. The Relational Pseudo-class: :has()

The relational pseudo-class, :has(), is a functional pseudo-class taking a relative selector list as an argument. It represents an element if any of the relative selectors, when absolutized and evaluated with the element as the :scope elements, would match at least one element.

For example, the following selector matches only <a> elements that contain an <img> child:
a:has(> img)

The following selector matches a <dt> element immediately followed by another <dt> element:

dt:has(+ dt)

The following selector matches <section> elements that don’t contain any heading elements:

section:not(:has(h1, h2, h3, h4, h5, h6))

Note that ordering matters in the above selector. Swapping the nesting of the two pseudo-classes, like:

section:has(:not(h1, h2, h3, h4, h5, h6))

...would result matching any <section> element which contains anything that’s not a header element.

5. Elemental selectors

5.1. Type (tag name) selector

A type selector is the name of a document language element type, and represents an instance of that element type in the document tree.

For example, the selector h1 represents an h1 element in the document.

A type selector is written as a CSS qualified name: an identifier with an optional namespace prefix. [CSS3NAMESPACE] (See §5.3 Namespaces in Elemental Selectors.)

5.2. Universal selector

The universal selector is a special type selector, that represents an element of any element type.

It is written a CSS qualified name with an asterisk (* U+002A) as the local name. Like a type selector, the universal selector can be qualified by a namespace, restricting it to only elements belonging to that namespace, and is affected by a default namespace as defined in §5.3 Namespaces in Elemental Selectors.

Unless an element is featureless, the presence of a universal selector has no effect on whether the element matches the selector. (Featureless elements do not match any selector, including the universal selector.)

The universal selector follows the same syntax rules as other type selectors: only one can appear per compound selector, and it must be the first simple selector in the compound selector.

Note: In some cases, adding a universal selector can make a selector easier to read, even though it has no effect on the matching behavior. For example, div :first-child and div:first-child are somewhat difficult to tell apart at a quick glance, but writing the former as div *:first-child makes the difference obvious.

5.3. Namespaces in Elemental Selectors

Type selectors and universal selectors allow an optional namespace component: a namespace prefix that has been previously declared may be prepended to the element name separated by the namespace separator “vertical bar” (| U+007C). (See, e.g., [XML-NAMES] for the use of namespaces in XML.) It has the following meaning in each form:

ns|E
elements with name E in namespace ns
*|E
elements with name E in any namespace, including those without a namespace
|E
elements with name E without a namespace
E
if no default namespace has been declared for selectors, this is equivalent to *|E. Otherwise it is equivalent to ns|E where ns is the default namespace.
CSS examples:
@namespace foo url(http://www.example.com);
foo|h1 { color: blue }  /* first rule */
foo|* { color: yellow } /* second rule */
|h1 { color: red }      /* ...*/
*|h1 { color: green }
h1 { color: green }

The first rule (not counting the @namespace at-rule) will match only h1 elements in the "http://www.example.com" namespace.

The second rule will match all elements in the "http://www.example.com" namespace.

The third rule will match only h1 elements with no namespace.

The fourth rule will match h1 elements in any namespace (including those without any namespace).

The last rule is equivalent to the fourth rule because no default namespace has been defined.

If a default namespace is declared, compound selectors without type selectors in them still only match elements in that default namespace.

For example, in the following stylesheet:
@namespace url("http://example.com/foo");

.special { ... }

The .special selector only matches elements in the "http://example.com/foo" namespace, even though no reference to the type name (which is paired with the namespace in the DOM) appeared.

A type selector or universal selector containing a namespace prefix that has not been previously declared is an invalid selector.

6. Attribute selectors

Selectors allow the representation of an element’s attributes. When a selector is used as an expression to match against an element, an attribute selector must be considered to match an element if that element has an attribute that matches the attribute represented by the attribute selector.

Add comma-separated syntax for multiple-value matching? e.g. [rel ~= next, prev, up, first, last]

6.1. Attribute presence and value selectors

CSS2 introduced four attribute selectors:

[att]
Represents an element with the att attribute, whatever the value of the attribute.
[att=val]
Represents an element with the att attribute whose value is exactly "val".
[att~=val]
Represents an element with the att attribute whose value is a whitespace-separated list of words, one of which is exactly "val". If "val" contains whitespace, it will never represent anything (since the words are separated by spaces). Also if "val" is the empty string, it will never represent anything.
[att|=val]
Represents an element with the att attribute, its value either being exactly "val" or beginning with "val" immediately followed by "-" (U+002D). This is primarily intended to allow language subcode matches (e.g., the hreflang attribute on the a element in HTML) as described in BCP 47 ([BCP47]) or its successor. For lang (or xml:lang) language subcode matching, please see the :lang pseudo-class.

Attribute values must be <ident-token>s or <string-token>s. [CSS3SYN]

Examples:

The following attribute selector represents an h1 element that carries the title attribute, whatever its value:

h1[title]

In the following example, the selector represents a span element whose class attribute has exactly the value "example":

span[class="example"]

Multiple attribute selectors can be used to represent several attributes of an element, or several conditions on the same attribute. Here, the selector represents a span element whose hello attribute has exactly the value "Cleveland" and whose goodbye attribute has exactly the value "Columbus":

span[hello="Cleveland"][goodbye="Columbus"]

The following CSS rules illustrate the differences between "=" and "~=". The first selector would match, for example, an a element with the value "copyright copyleft copyeditor" on a rel attribute. The second selector would only match an a element with an href attribute having the exact value "http://www.w3.org/".

a[rel~="copyright"] { ... }
a[href="http://www.w3.org/"] { ... }

The following selector represents an a element whose hreflang attribute is exactly "fr".

a[hreflang=fr] 

The following selector represents an a element for which the value of the hreflang attribute begins with "en", including "en", "en-US", and "en-scouse":

a[hreflang|="en"] 

The following selectors represent a DIALOGUE element whenever it has one of two different values for an attribute character:

DIALOGUE[character=romeo]
DIALOGUE[character=juliet]

6.2. Substring matching attribute selectors

Three additional attribute selectors are provided for matching substrings in the value of an attribute:

[att^=val]
Represents an element with the att attribute whose value begins with the prefix "val". If "val" is the empty string then the selector does not represent anything.
[att$=val]
Represents an element with the att attribute whose value ends with the suffix "val". If "val" is the empty string then the selector does not represent anything.
[att*=val]
Represents an element with the att attribute whose value contains at least one instance of the substring "val". If "val" is the empty string then the selector does not represent anything.

Attribute values must be <ident-token>s or <string-token>s.

Examples: The following selector represents an HTML object element, referencing an image:
object[type^="image/"] 

The following selector represents an HTML a element with an href attribute whose value ends with ".html".

a[href$=".html"] 

The following selector represents an HTML paragraph with a title attribute whose value contains the substring "hello"

p[title*="hello"] 

6.3. Case-sensitivity

By default case-sensitivity of attribute names and values in selectors depends on the document language. To match attribute values case-insensitively regardless of document language rules, the attribute selector may include the identifier i before the closing bracket (]). When this flag is present, UAs must match the attribute’s value case-insensitively within the ASCII range. Like the rest of Selectors syntax, the i identifier is case-insensitive within the ASCII range.

The following rule will style the frame attribute when it has a value of hsides, whether that value is represented as hsides, HSIDES, hSides, etc. even in an XML environment where attribute values are case-sensitive.
[frame=hsides i] { border-style: solid none; } 

6.4. Attribute selectors and namespaces

The attribute name in an attribute selector is given as a CSS qualified name: a namespace prefix that has been previously declared may be prepended to the attribute name separated by the namespace separator "vertical bar" (|). In keeping with the Namespaces in the XML recommendation, default namespaces do not apply to attributes, therefore attribute selectors without a namespace component apply only to attributes that have no namespace (equivalent to |attr). An asterisk may be used for the namespace prefix indicating that the selector is to match all attribute names without regard to the attribute’s namespace.

An attribute selector with an attribute name containing a namespace prefix that has not been previously declared is an invalid selector.

CSS examples:
@namespace foo "http://www.example.com";
[foo|att=val] { color: blue }
[*|att] { color: yellow }
[|att] { color: green }
[att] { color: green }

The first rule will match only elements with the attribute att in the "http://www.example.com" namespace with the value "val".

The second rule will match only elements with the attribute att regardless of the namespace of the attribute (including no namespace).

The last two rules are equivalent and will match only elements with the attribute att where the attribute is not in a namespace.

6.5. Default attribute values in DTDs

Attribute selectors represent attribute values in the document tree. How that document tree is constructed is outside the scope of Selectors. In some document formats default attribute values can be defined in a DTD or elsewhere, but these can only be selected by attribute selectors if they appear in the document tree. Selectors should be designed so that they work whether or not the default values are included in the document tree.

For example, a XML UA may, but is not required to, read an “external subset” of the DTD, but is required to look for default attribute values in the document’s “internal subset”. (See, e.g., [XML10] for definitions of these subsets.) Depending on the UA, a default attribute value defined in the external subset of the DTD might or might not appear in the document tree.

A UA that recognizes an XML namespace may, but is not required to use its knowledge of that namespace to treat default attribute values as if they were present in the document. (For example, an XHTML UA is not required to use its built-in knowledge of the XHTML DTD. See, e.g., [XML-NAMES] for details on namespaces in XML 1.0.)

Note: Typically, implementations choose to ignore external subsets. This corresponds to the behaviour of non-validating processors as defined by the XML specification.

Example:

Consider an element EXAMPLE with an attribute radix that has a default value of "decimal". The DTD fragment might be

<!ATTLIST EXAMPLE radix (decimal,octal) "decimal"> 

If the style sheet contains the rules

EXAMPLE[radix=decimal] { /*... default property settings ...*/ }
EXAMPLE[radix=octal]   { /*... other settings...*/ }

the first rule might not match elements whose radix attribute is set by default, i.e. not set explicitly. To catch all cases, the attribute selector for the default value must be dropped:

EXAMPLE                { /*... default property settings ...*/ }
EXAMPLE[radix=octal]   { /*... other settings...*/ }

Here, because the selector ''EXAMPLE[radix=octal]'' is more specific than the type selector alone, the style declarations in the second rule will override those in the first for elements that have a radix attribute value of "octal". Care has to be taken that all property declarations that are to apply only to the default case are overridden in the non-default cases' style rules.

6.6. Class selectors

The class selector is given as a full stop (. U+002E) immediately followed by an identifier. It represents an element belonging to the class identified by the identifier, as defined by the document language. For example, in [HTML5], [SVG11], and [MATHML] membership in a class is given by the class attribute: in these languages it is equivalent to the ~= notation applied to the local class attribute (i.e. [class~=identifier]).

CSS examples:

We can assign style information to all elements with class~="pastoral" as follows:

*.pastoral { color: green }  /* all elements with class~=pastoral */ 

or just

.pastoral { color: green }  /* all elements with class~=pastoral */ 

The following assigns style only to H1 elements with class~="pastoral":

H1.pastoral { color: green }  /* H1 elements with class~=pastoral */ 

Given these rules, the first H1 instance below would not have green text, while the second would:

<H1>Not green</H1>
<H1 class="pastoral">Very green</H1>

The following rule matches any P element whose class attribute has been assigned a list of whitespace-separated values that includes both pastoral and marine:

p.pastoral.marine { color: green } 

This rule matches when class="pastoral blue aqua marine" but does not match for class="pastoral blue".

Note: Because CSS gives considerable power to the "class" attribute, authors could conceivably design their own "document language" based on elements with almost no associated presentation (such as div and span in HTML) and assigning style information through the "class" attribute. Authors should avoid this practice since the structural elements of a document language often have recognized and accepted meanings and author-defined classes may not.

Note: If an element has multiple class attributes, their values must be concatenated with spaces between the values before searching for the class. As of this time the working group is not aware of any manner in which this situation can be reached, however, so this behavior is explicitly non-normative in this specification.

When matching against a document which is in quirks mode, class names must be matched ASCII case-insensitively; class selectors are otherwise case-sensitive.

6.7. ID selectors

Document languages may contain attributes that are declared to be of type ID. What makes attributes of type ID special is that no two such attributes can have the same value in a conformant document, regardless of the type of the elements that carry them; whatever the document language, an ID typed attribute can be used to uniquely identify its element. In HTML all ID attributes are named id; XML applications may name ID attributes differently, but the same restriction applies. Which attribute on an element is considered the “ID attribute“ is defined by the document language.

An ID selector consists of a “number sign” (U+0023, #) immediately followed by the ID value, which must be a CSS identifier. An ID selector represents an element instance that has an identifier that matches the identifier in the ID selector. (It is possible in non-conforming documents for multiple elements to match a single ID selector.)

Examples: The following ID selector represents an h1 element whose ID-typed attribute has the value "chapter1":
h1#chapter1 

The following ID selector represents any element whose ID-typed attribute has the value "chapter1":

#chapter1 

The following selector represents any element whose ID-typed attribute has the value "z98y".

*#z98y 

Note: In XML 1.0 [XML10], the information about which attribute contains an element’s IDs is contained in a DTD or a schema. When parsing XML, UAs do not always read the DTD, and thus may not know what the ID of an element is (though a UA may have namespace-specific knowledge that allows it to determine which attribute is the ID attribute for that namespace). If a style sheet author knows or suspects that a UA may not know what the ID of an element is, he should use normal attribute selectors instead: ''[name=p371] instead of #p371''.

If an element has multiple ID attributes, all of them must be treated as IDs for that element for the purposes of the ID selector. Such a situation could be reached using mixtures of xml:id, DOM3 Core, XML DTDs, and namespace-specific knowledge.

When matching against a document which is in quirks mode, IDs must be matched ASCII case-insensitively; ID selectors are otherwise case-sensitive.

7. Linguistic Pseudo-classes

7.1. The Directionality Pseudo-class: :dir()

The :dir() pseudo-class allows the author to write selectors that represent an element based on its directionality as determined by the document language. For example, [HTML5] defines how to determine the directionality of an element, based on a combination of the dir attribute, the surrounding text, and other factors. The :dir() pseudo-class does not select based on stylistic states—for example, the CSS direction property does not affect whether it matches.

The pseudo-class :dir(ltr) represents an element that has a directionality of left-to-right (ltr). The pseudo-class :dir(rtl) represents an element that has a directionality of right-to-left (rtl). The argument to :dir() must be a single identifier, otherwise the selector is invalid. White space is optionally allowed between the identifier and the parentheses. Values other than ltr and rtl are not invalid, but do not match anything. (If a future markup spec defines other directionalities, then Selectors may be extended to allow corresponding values.)

The difference between :dir(C) and ''[dir=C]'' is that ''[dir=C]'' only performs a comparison against a given attribute on the element, while the :dir(C) pseudo-class uses the UAs knowledge of the document’s semantics to perform the comparison. For example, in HTML, the directionality of an element inherits so that a child without a dir attribute will have the same directionality as its closest ancestor with a valid dir attribute. As another example, in HTML, an element that matches ''[dir=auto]'' will match either :dir(ltr) or :dir(rtl) depending on the resolved directionality of the elements as determined by its contents. [HTML5]

7.2. The Language Pseudo-class: :lang()

If the document language specifies how the (human) content language of an element is determined, it is possible to write selectors that represent an element based on its language. The :lang() pseudo-class represents an element that is in one of the languages listed in its argument. It accepts a comma-separated list of one or more language ranges as its argument. Each language range in :lang() must be a valid CSS <ident> or <string>. (Language ranges containing asterisks, for example, must be quoted as strings.)

The language of an element is defined by the document language. For example, in HTML [HTML401], the language is determined by a combination of the lang attribute, information from meta elements, and possibly also the protocol (e.g. from HTTP headers). XML languages can use the xml:lang attribute to indicate language information for an element.

The element’s language matches a language range if the element’s language (normalized to BCP 47 syntax if necessary) matches the given language range in an extended filtering operation per [RFC4647] Matching of Language Tags (section 3.3.2). The matching is performed case-insensitively within the ASCII range. The language range does not need to be a valid language code to perform this comparison.

Note: It is recommended that documents and protocols indicate language using codes from BCP 47 [BCP47] or its successor, and by means of xml:lang attributes in the case of XML-based documents [XML10]. See "FAQ: Two-letter or three-letter language codes."

Examples: The two following selectors represent an HTML document that is in Belgian French or German. The two next selectors represent q quotations in an arbitrary element in Belgian French or German.
html:lang(fr-be)
html:lang(de)
:lang(fr-be) > q
:lang(de) > q

Note: One difference between :lang(C) and the ''|='' operator is that the ''|='' operator only performs a comparison against a given attribute on the element, while the :lang(C) pseudo-class uses the UAs knowledge of the document’s semantics to perform the comparison.

In this HTML example, only the BODY matches ''[lang|=fr]'' (because it has a LANG attribute) but both the BODY and the P match :lang(fr) (because both are in French). The P does not match the ''[lang|=fr]'' because it does not have a LANG attribute.
<body lang=fr>
  <p>Je suis français.</p>
</body>
Another difference between :lang(C) and the ''|='' operator is that :lang(C) performs implicit wildcard matching.

For example, :lang(de-DE) will match all of de-DE, de-DE-1996, de-Latn-DE, de-Latf-DE, de-Latn-DE-1996, whereas of those ''[lang|=de-DE] will only match de-DE'' and de-DE-1996.

To perform wildcard matching on the first subtag (the primary language), an asterisk must be used: *-CH will match all of de-CH, it-CH, fr-CH, and rm-CH.

Note: Wildcard language matching is new in Level 4.

8. Location Pseudo-classes

The :any-link pseudo-class represents an element that acts as the source anchor of a hyperlink. For example, in [HTML5], any a, area, or link elements with an href attribute are hyperlinks, and thus match :any-link. It matches an element if the element would match :link or :visited, equivalent to :matches(:link, :visited).

Any better name suggestions for this pseudo?

User agents commonly display unvisited hyperlinks differently from previously visited ones. Selectors provides the pseudo-classes :link and :visited to distinguish them:

After some amount of time, user agents may choose to return a visited link to the (unvisited) :link state.

The two states are mutually exclusive.

The following selector represents links carrying class footnote and already visited:
.footnote:visited 

Since it is possible for style sheet authors to abuse the :link and :visited pseudo-classes to determine which sites a user has visited without the user’s consent, UAs may treat all links as unvisited links or implement other measures to preserve the user’s privacy while rendering visited and unvisited links differently.

8.3. The Target Pseudo-class: :target

In some document languages, the document’s URL can further point to specific elements within the document via the URL’s fragment. The elements pointed to in this way are the target elements of the document.

In HTML the fragment points to the element in the page with the same ID. The url https://example.com/index.html#section2, for example, points to the element with id="section2" in the document at https://example.com/index.html.

The :target pseudo-class matches the document’s target elements. If the document’s URL has no fragment identifier, then the document has no target elements.

Example:
p.note:target 

This selector represents a p element of class note that is the target element of the referring URL.

CSS example: Here, the :target pseudo-class is used to make the target element red and place an image before it, if there is one:
:target { color : red }
:target::before { content : url(target.png) }

8.4. The Reference Element Pseudo-class: :scope

In some contexts, selectors can be matched with an explicit set of :scope elements. This is is a (potentially empty) set of elements that provide a reference point for selectors to match against, such as that specified by the querySelector() call in [DOM], or the parent element of a scoped <style> element in [HTML5].

The :scope pseudo-class represents any element that is a :scope element. If the :scope elements are not explicitly specified, but the selector is scoped and the scoping root is an element, then :scope represents the scoping root; otherwise, it represents the root of the document (equivalent to :root). Specifications intending for this pseudo-class to match specific elements rather than the document’s root element must define either a scoping root (if using scoped selectors) or an explicit set of :scope elements.

9. User Action Pseudo-classes

Interactive user agents sometimes change the rendering in response to user actions. Selectors provides several pseudo-classes for the selection of an element the user is acting on. (In non-interactive user agents, these pseudo-classes are valid, but never match any element.)

These pseudo-classes are not mutually exclusive. An element may match several pseudo-classes at the same time.

Examples:
a:link    /* unvisited links */
a:visited /* visited links */
a:hover   /* user hovers */
a:active  /* active links */

An example of combining dynamic pseudo-classes:

a:focus
a:focus:hover

The last selector matches a elements that are in the pseudo-class :focus and in the pseudo-class :hover.

Note: The specifics of hit-testing, necessary to know when several of the pseudo-classes defined in this section apply, are not yet defined, but will be in the future.

9.1. The Pointer Hover Pseudo-class: :hover

The :hover pseudo-class applies while the user designates an element with a pointing device, but does not necessarily activate it. For example, a visual user agent could apply this pseudo-class when the cursor (mouse pointer) hovers over a box generated by the element. Interactive user agents that cannot detect hovering due to hardware limitations (e.g., a pen device that does not detect hovering) are still conforming.

An element also matches :hover if one of its shadow-including descendants matches :hover.

Document languages may define additional ways in which an element can match :hover. For example, [HTML5] defines a labeled control element as matching :hover when its label is hovered.

Note: Since the ':hover' state can apply to an element because its child is designated by a pointing device, then it is possible for ':hover' to apply to an element that is not underneath the pointing device.

The :hover pseudo-class can apply to any pseudo-element.

9.2. The Activation Pseudo-class: :active

The :active pseudo-class applies while an element is being activated by the user. For example, between the times the user presses the mouse button and releases it. On systems with more than one mouse button, :active applies only to the primary or primary activation button (typically the "left" mouse button), and any aliases thereof.

There may be document language or implementation specific limits on which elements can become :active. For example, [HTML5] defines a list of activatable elements.

An element also matches :active if one of its shadow-including descendants matches :active.

Document languages may define additional ways in which an element can match :active.

Note: An element can be both ':visited' and ':active' (or ':link' and ':active').

9.3. The Input Focus Pseudo-class: :focus

The :focus pseudo-class applies while an element has the focus (accepts keyboard or mouse events, or other forms of input).

There may be document language or implementation specific limits on which elements can acquire :focus. For example, [HTML5] defines a list of activatable elements.

If the document language has defined additional ways by which an element can match :active, the same ways must apply to elements matching :focus as well, except that the parent of an element that matches :focus must not match :focus.

9.4. The Input Focus-Ring Pseudo-class: :focus-ring

The :focus-ring pseudo-class applies while an element matches the :focus pseudo-class, and the UA determines via heuristics that the focus should be specially indicated on the element (typically via a "focus ring").

For example, UAs typically display focus indicators on text elements whenever they’re focused, to draw attention to the fact that keyboard input will affect their contents.

On the other hand, they typically only display focus indicators on buttons when they were focused by a keyboard interaction (such as tabbing thru the document), because it’s not always immediately obvious where the focus will move after such an interaction, but not when they were focused by more "obvious" interactions, like clicking on the button with a mouse pointer.

Page authors should follow these guidelines when deciding whether to use :focus or :focus-ring to style the focused state of an element:

When UAs choose to specially indicate focus on an element, or whether they specially indicate focus at all, is UA-dependent. Different UAs, the same UA on different operating systems, or the same UA on the same OS, but with different user settings, can make different choices as to when an element matches :focus-ring.

The following guidelines are suggested heuristics for choosing when to apply :focus-ring to elements without "native" focus ring behavior:

9.5. The Generalized Input Focus Pseudo-class: :focus-within

The :focus-within pseudo-class applies to elements for which the :focus pseudo class applies.

An element also matches :focus-within if one of its shadow-including descendants matches :focus.

9.6. The Drag-and-Drop Pseudo-class: :drop and :drop()

The :drop pseudo-class applies to all elements that are drop targets, as defined by the document language, while the user is “dragging” or otherwise conceptually carrying an item to be “dropped”. For example, in HTML the dropzone attribute specified that an element is a drop target.

The :drop() functional pseudo-class is identical to :drop, but allows additional filters to be specified that can exclude some drop targets. Its syntax is:

:drop( [ active || valid || invalid ]? ) 

The keywords have the following meanings:

active
The drop target is the current drop target for the drag operation. That is, if the user were to release the drag, it would be dropped onto this drop target.
valid
If the document language has a concept of “valid” and “invalid” drop targets, this only matches if the drop target is valid for the object currently being dragged. Otherwise, it matches all drop targets.

For example, HTML’s dropzone attribute can specify that the drop target only accepts strings or files that are set to a given type.

invalid
If the document language has a concept of “valid” and “invalid” drop targets, this only matches if the drop target is invalid for the object currently being dragged. Otherwise, it matches nothing.

Multiple keywords can be combined in the argument, representing only drop targets that satisfy all of the keywords. For example, :drop(valid active) will match the active drop target if it’s valid, but not if it’s invalid.

If no keywords are given in the argument, :drop() has the same meaning as :dropit matches every drop target.

Turn this scenario into an example.

10. Time-dimensional Pseudo-classes

These pseudo-classes classify elements with respect to the currently-displayed or active position in some timeline, such as during speech rendering of a document, or during the display of a video using WebVTT to render subtitles.

CSS does not define this timeline; the host language must do so. If there is no timeline defined for an element, these pseudo-classes must not match the element.

Note: Ancestors of a :current element are also :current, but ancestors of a :past or :future element are not necessarily :past or :future as well. A given element matches at most one of :current, :past, or :future.

10.1. The Current-element Pseudo-class: :current

The :current pseudo-class represents the element, or an ancestor of the element, that is currently being displayed.

Its alternate form :current(), like :matches(), takes a list of compound selectors as its argument: it represents the :current element that matches the argument or, if that does not match, the innermost ancestor of the :current element that does. (If neither the :current element nor its ancestors match the argument, then the selector does not represent anything.)

For example, the following rule will highlight whichever paragraph or list item is being read aloud in a speech rendering of the document:
:current(p, li, dt, dd) {
  background: yellow;
}

10.2. The Past-element Pseudo-class: :past

The :past pseudo-class represents any element that is defined to occur entirely prior to a :current element. For example, the WebVTT spec defines the :past pseudo-class relative to the current playback position of a media element. If a time-based order of elements is not defined by the document language, then this represents any element that is a (possibly indirect) previous sibling of a :current element.

10.3. The Future-element Pseudo-class: :future

The :future pseudo-class represents any element that is defined to occur entirely after a :current element. For example, the WebVTT spec defines the :future pseudo-class relative to the current playback position of a media element. If a time-based order of elements is not defined by the document language, then this represents any element that is a (possibly indirect) next sibling of a :current element.

11. Resource State Pseudos

The pseudo-classes in this section apply to elements that represent loaded resources, particularly images/videos, and allow authors to select them based on some quality of their "state".

11.1. Video/Audio Play State: the :playing and :paused pseudo-classes

The :playing pseudo-class represents an element representing an audio, video, or similar resource that is capable of being "played" or "paused", when that element is "playing". (This includes both when the element is explicitly playing, and when it’s temporarily stopped for some reason not connected to user intent, but will automatically resume when that reason is resolved, such as a "buffering" state.)

The :paused pseudo-class represents the same elements, but instead match when the element is not "playing". (This includes both an explicit "paused" state, and other non-playing states like "loaded, hasn’t been activated yet", etc.)

12. The Input Pseudo-classes

The pseudo-classes in this section mostly apply to elements that take user input, such as HTML’s input element.

12.1. Input Control States

12.1.1. The :enabled and :disabled Pseudo-classes

The :enabled pseudo-class represents user interface elements that are in an enabled state; such elements have a corresponding disabled state.

Conversely, the :disabled pseudo-class represents user interface elements that are in a disabled state; such elements have a corresponding enabled state.

What constitutes an enabled state, a disabled state, and a user interface element is host-language-dependent. In a typical document most elements will be neither :enabled nor :disabled. For example, [HTML5] defines non-disabled interactive elements to be :enabled, and any such elements that are explicitly disabled to be :disabled.

Note: CSS properties that might affect a user’s ability to interact with a given user interface element do not affect whether it matches :enabled or :disabled; e.g., the display and visibility properties have no effect on the enabled/disabled state of an element.

12.1.2. The Mutability Pseudo-classes: :read-only and :read-write

An element matches :read-write if it is user-alterable, as defined by the document language. Otherwise, it is :read-only.

For example, in [HTML5] a non-disabled non-readonly <input> element is :read-write, as is any element with the contenteditable attribute set to the true state.

12.1.3. The Placeholder-shown Pseudo-class: :placeholder-shown

Input elements can sometimes show placeholder text as a hint to the user on what to type in. See, for example, the placeholder attribute in [HTML5]. The :placeholder-shown pseudo-class matches an input element that is showing such placeholder text.

12.1.4. The Default-option Pseudo-class: :default

The :default pseudo-class applies to the one or more UI elements that are the default among a set of similar elements. Typically applies to context menu items, buttons and select lists/menus.

One example is the default submit button among a set of buttons. Another example is the default option from a popup menu. In a select-many group (such as for pizza toppings), multiple elements can match :default. For example, [HTML5] defines that :default matches the “default button” in a form, the initially-selected <option>(s) in a <select>, and a few other elements.

12.2. Input Value States

12.2.1. The Selected-option Pseudo-class: :checked

Radio and checkbox elements can be toggled by the user. Some menu items are "checked" when the user selects them. When such elements are toggled "on" the :checked pseudo-class applies. For example, [HTML5] defines that checked checkboxes, radio buttons, and selected <option> elements match :checked.

While the :checked pseudo-class is dynamic in nature, and can altered by user action, since it can also be based on the presence of semantic attributes in the document (such as the selected and checked attributes in [HTML5]), it applies to all media.

An unchecked checkbox can be selected by using the negation pseudo-class:
input[type=checkbox]:not(:checked)

12.2.2. The Indeterminate-value Pseudo-class: :indeterminate

The :indeterminate pseudo-class applies to UI elements whose value is in an indeterminate state. For example, radio and checkbox elements can be toggled between checked and unchecked states, but are sometimes in an indeterminate state, neither checked nor unchecked. Similarly a progress meter can be in an indeterminate state when the percent completion is unknown. For example, [HTML5] defines how checkboxes can be made to match :indeterminate.

Like the :checked pseudo-class, :indeterminate applies to all media. Components of a radio-group initialized with no pre-selected choice, for example, would be :indeterminate even in a static display.

12.3. Input Value-checking

12.3.1. The Validity Pseudo-classes: :valid and :invalid

An element is :valid or :invalid when its contents or value is, respectively, valid or invalid with respect to data validity semantics defined by the document language (e.g. [XFORMS11] or [HTML5]). An element which lacks data validity semantics is neither :valid nor :invalid.

Note: There is a difference between an element which has no constraints, and thus would always be :valid, and one which has no data validity semantics at all, and thus is neither :valid nor :invalid. In HTML, for example, an <input type="text"> element may have no constraints, but a p element has no validity semantics at all, and so it never matches either of these pseudo-classes.

12.3.2. The Range Pseudo-classes: :in-range and :out-of-range

The :in-range and :out-of-range pseudo-classes apply only to elements that have range limitations. An element is :in-range or :out-of-range when the value that the element is bound to is in range or out of range with respect to its range limits as defined by the document language. An element that lacks data range limits or is not a form control is neither :in-range nor :out-of-range. E.g. a slider element with a value of 11 presented as a slider control that only represents the values from 1-10 is :out-of-range. Another example is a menu element with a value of "E" that happens to be presented in a popup menu that only has choices "A", "B" and "C".

12.3.3. The Optionality Pseudo-classes: :required and :optional

A form element is :required or :optional if a value for it is, respectively, required or optional before the form it belongs to can be validly submitted. Elements that are not form elements are neither required nor optional.

12.3.4. The User-interaction Pseudo-class: :user-invalid

The :user-invalid pseudo-class represents an element with incorrect input, but only after the user has significantly interacted with it. The :user-error pseudo-class must match an :invalid, :out-of-range, or blank-but-:required elements between the time the user has attempted to submit the form and before the user has interacted again with the form element. User-agents may allow it to match such elements at other times, as would be appropriate for highlighting an error to the user. For example, a UA may choose to have :user-error match an :invalid element once the user has typed some text into it and changed the focus to another element, and to stop matching only after the user has successfully corrected the input.

For example, the input in the following document fragment would match :invalid as soon as the page is loaded (because it the initial value violates the max-constraint), but it won’t match :user-error until the user significantly interacts with the element, or attempts to submit the form it’s part of.
<form>
  <label>
    Volume:
    <input name='vol' type=number min=0 max=10 value=11>
  </label>
  ...
</form>

Cross-check with :-moz-ui-invalid.

Add :-moz-ui-valid as :user-valid per WG resolution.

Evaluate proposed :dirty pseudo-class

Clarify that this (and :invalid/:valid) can apply to form and fieldset elements.

13. Tree-Structural pseudo-classes

Selectors introduces the concept of structural pseudo-classes to permit selection based on extra information that lies in the document tree but cannot be represented by other simple selectors or combinators.

Standalone text and other non-element nodes are not counted when calculating the position of an element in the list of children of its parent. When calculating the position of an element in the list of children of its parent, the index numbering starts at 1.

The structural pseudo-classes only apply to elements in the document tree; they must never match pseudo-elements.

13.1. :root pseudo-class

The :root pseudo-class represents an element that is the root of the document.

For example, in a DOM document, the :root pseudo-class matches the root element of the Document object. In HTML, this would be the html element (unless scripting has been used to modify the document).

13.2. :empty pseudo-class

The :empty pseudo-class represents an element that has no children at all. In terms of the document tree, only element nodes and content nodes (such as [DOM] text nodes, and entity references) whose data has a non-zero length must be considered as affecting emptiness; comments, processing instructions, and other nodes must not affect whether an element is considered empty or not.

Examples: p:empty is a valid representation of the following fragment:
<p></p>

foo:empty is not a valid representation for the following fragments:

<foo>bar</foo>
<foo><bar>bla</bar></foo>
<foo>this is not <bar>:empty</bar></foo>

13.3. :blank pseudo-class

The :blank pseudo-class is like the :empty pseudo-class, except that it additionally matches elements that only contain code points affected by whitespace processing. [CSS3TEXT]

For example, the following element matches :blank, but not :empty, because it contains at least one linebreak, and possibly other whitespace:
<p>    
</p>

We don’t like the name :blankit doesn’t clearly convey a difference from :empty. Moz uses :-moz-whitespace-only, which is clear but a little wordy. Any other suggestions?

13.4. Child-indexed Pseudo-classes

The pseudo-classes defined in this section select elements based on their index amongst their inclusive siblings.

Note: Selectors 3 described these selectors as selecting elements based on their index in the child list of their parents. (This description survives in the name of this very section, and the names of several of the pseudo-classes.) As there was no reason to exclude them from matching elements without parents, or with non-element parents, they have been rephrased to refer to an element’s relative index amongst its siblings.

13.4.1. :nth-child() pseudo-class

The :nth-child(An+B [of S]? ) pseudo-class notation represents the An+Bth element that matches the selector list S among its inclusive siblings.

The CSS Syntax Module [CSS3SYN] defines the An+B notation. If S is omitted, it defaults to *.

For example, this selector could address every other row in a table, and could be used to alternate the color of paragraph text in a cycle of four.

Examples:
:nth-child(even)   /* represents the 2nd, 4th, 6th, etc elements
:nth-child(10n-1)  /* represents the 9th, 19th, 29th, etc elements */
:nth-child(10n+9)  /* Same */
:nth-child(10n+-1) /* Syntactically invalid, and would be ignored */
By passing a selector argument, we can select the Nth element that matches that selector. For example, the following selector matches the first three “important” list items, denoted by the .important class:
:nth-child(-n+3 of li.important)

Note that this is different from moving the selector outside of the function, like:

li.important:nth-child(-n+3)

This selector instead just selects the first three children if they also happen to be "important" list items.

Here’s another example of using the selector argument, to ensure that zebra-striping a table works correctly.

Normally, to zebra-stripe a table’s rows, an author would use CSS similar to the following:

tr {
  background: white;
}
tr:nth-child(even) {
  background: silver;
}

However, if some of the rows are hidden and not displayed, this can break up the pattern, causing multiple adjacent rows to have the same background color. Assuming that rows are hidden with the [hidden] attribute in HTML, the following CSS would zebra-stripe the table rows robustly, maintaining a proper alternating background regardless of which rows are hidden:

tr {
  background: white;
}
tr:nth-child(even of :not([hidden])) {
  background: silver;
}

13.4.2. :nth-last-child() pseudo-class

The :nth-last-child(An+B [of S]? ) pseudo-class notation represents the An+Bth element that matches the selector list S among its inclusive siblings, counting backwards from the end.

The CSS Syntax Module [CSS3SYN] defines the An+B notation. If S is omitted, it defaults to *.

Examples:
tr:nth-last-child(-n+2)    /* represents the two last rows of an HTML table */

foo:nth-last-child(odd)    /* represents all odd foo elements in their parent element,
                              counting from the last one */

13.4.3. :first-child pseudo-class

The :first-child pseudo-class represents an element that if first among its inclusive siblings. Same as :nth-child(1).

Examples: The following selector represents a p element that is the first child of a div element:
div > p:first-child

This selector can represent the p inside the div of the following fragment:

<p> The last P before the note.</p>
<div class="note">
   <p> The first P inside the note.</p>
</div>

but cannot represent the second p in the following fragment:

<p> The last P before the note.</p>
<div class="note">
   <h2> Note </h2>
   <p> The first P inside the note.</p>
</div>

The following two selectors are usually equivalent:

* > a:first-child /* a is first child of any element */
a:first-child /* Same (assuming a is not the root element) */

13.4.4. :last-child pseudo-class

The :last-child pseudo-class represents an element that is last among its inclusive siblings. Same as :nth-last-child(1).

Example: The following selector represents a list item li that is the last child of an ordered list ol.
ol > li:last-child

13.4.5. :only-child pseudo-class

The :only-child pseudo-class represents an element that has no siblings. Same as :first-child:last-child or :nth-child(1):nth-last-child(1), but with a lower specificity.

13.5. Typed Child-indexed Pseudo-classes

The pseudo-elements in this section are similar to the Child Index Pseudo-classes, but they resolve based on an element’s index among elements of the same type (tag name) in their sibling list.

13.5.1. :nth-of-type() pseudo-class

The :nth-of-type(An+B) pseudo-class notation represents the An+Bth element with the same namespace and type among its inclusive siblings.

The CSS Syntax Module [CSS3SYN] defines the An+B notation.

CSS example: This allows an author to alternate the position of floated images:
img:nth-of-type(2n+1) { float: right; }
img:nth-of-type(2n) { float: left; }

Note: If the type of the element is known ahead of time, this pseudo-class is equivalent to using :nth-child() with a type selector. That is, img:nth-of-type(2) is equivalent to *:nth-child(2 of img).

13.5.2. :nth-last-of-type() pseudo-class

The :nth-last-of-type(An+B) pseudo-class notation represents the An+Bth element with the same namespace and type among its inclusive siblings, counting backwards from the end.

The CSS Syntax Module [CSS3SYN] defines the An+B notation.

Example: To represent all h2 children of an XHTML body except the first and last, one could use the following selector:
body > h2:nth-of-type(n+2):nth-last-of-type(n+2) 

In this case, one could also use :not(), although the selector ends up being just as long:

body > h2:not(:first-of-type):not(:last-of-type) 

13.5.3. :first-of-type pseudo-class

The :first-of-type pseudo-class represents an element that is the first with a particular namespace and type among its inclusive siblings. Same as :nth-of-type(1).

Example: The following selector represents a definition title dt inside a definition list dl, this dt being the first of its type in the list of children of its parent element.
dl dt:first-of-type

It is a valid description for the first two dt elements in the following example but not for the third one:

<dl>
  <dt>gigogne</dt>
  <dd>
    <dl>
      <dt>fusée</dt>
      <dd>multistage rocket</dd>
      <dt>table</dt>
      <dd>nest of tables</dd>
    </dl>
  </dd>
</dl>

13.5.4. :last-of-type pseudo-class

The :last-of-type pseudo-class represents an element that is the first with a particular namespace and type among its inclusive siblings, counting backwards from the end. Same as :nth-last-of-type(1).

Example: The following selector represents the last data cell td of a table row tr.
tr > td:last-of-type

13.5.5. :only-of-type pseudo-class

The :only-of-type pseudo-class represents an element that has no siblings with the same namespace and type Same as :first-of-type:last-of-type or :nth-of-type(1):nth-last-of-type(1), but with a lower specificity.

14. Combinators

14.1. Descendant combinator ( ) or (>>)

At times, authors may want selectors to describe an element that is the descendant of another element in the document tree (e.g., "an em element that is contained within an H1 element"). The descendant combinator expresses such a relationship. It has two syntactic forms:

  1. whitespace that separates two compound selectors or
  2. A doubled child selector (>>)

A selector of the form A B or A >> B' represents an element B that is an arbitrary descendant of some ancestor element A.

Examples: For example, consider the following selector:
h1 em

It represents an em element being the descendant of an h1 element. It is a correct and valid, but partial, description of the following fragment:

<h1>This <span class="myclass">headline
is <em>very</em> important</span></h1>

The following selector:

div * p

represents a p element that is a grandchild or later descendant of a div element. Note the whitespace on either side of the "*" is not part of the universal selector; the whitespace is a combinator indicating that the div must be the ancestor of some element, and that that element must be an ancestor of the p. The following selector, which combines descendant combinators and attribute selectors, represents an element that (1) has the href attribute set and (2) is inside a p that is itself inside a div:

div p *[href]

Note: Note that the whitespace form has existed since CSS Level 1, whereas the >> form is introduced in Level 4. It was introduced to give the descendant combinator a visible, non-whitespace form and to bridge the gap between the child combinator (>) and the shadow-piercing descendant combinator (>>>) [CSS-SCOPING-1].

14.2. Child combinator (>)

A child combinator describes a childhood relationship between two elements. A child combinator is made of the "greater-than sign" (U+003E, >) code point and separates two compound selectors.

Examples: The following selector represents a p element that is child of body:
body > p

The following example combines descendant combinators and child combinators.

div ol>li p

It represents a p element that is a descendant of an li element; the li element must be the child of an ol element; the ol element must be a descendant of a div. Notice that the optional white space around the ">" combinator has been left out.

For information on selecting the first child of an element, please see the section on the :first-child pseudo-class above.

14.3. Next-sibling combinator (+)

The next-sibling combinator is made of the “plus sign” (U+002B, +) code point that separates two compound selectors. The elements represented by the two compound selectors share the same parent in the document tree and the element represented by the first compound selector immediately precedes the element represented by the second one. Non-element nodes (e.g. text between elements) are ignored when considering the adjacency of elements.

Examples: The following selector represents a p element immediately following a math element:
math + p

The following selector is conceptually similar to the one in the previous example, except that it adds an attribute selector — it adds a constraint to the h1 element, that it must have class="opener":

h1.opener + h2

14.4. Following-sibling combinator (~)

The following-sibling combinator is made of the "tilde" (U+007E, ~) code point that separates two compound selectors. The elements represented by the two compound selectors share the same parent in the document tree and the element represented by the first compound selector precedes (not necessarily immediately) the element represented by the second one.

h1 ~ pre

represents a pre element following an h1. It is a correct and valid, but partial, description of:

<h1>Definition of the function a</h1>
<p>Function a(x) has to be applied to all figures in the table.</p>
<pre>function a(x) = 12x/13.5</pre>

15. Grid-Structural Selectors

The double-association of a cell in a 2D grid (to its row and column) cannot be represented by parentage in a hierarchical markup language. Only one of those associations can be represented hierarchically: the other must be explicitly or implicitly defined in the document language semantics. In both HTML and DocBook, two of the most common hierarchical markup languages, the markup is row-primary (that is, the row associations are represented hierarchically); the columns must be implied. To be able to represent such implied column-based relationships, the column combinator and the :nth-column() and :nth-last-column() pseudo-classes are defined. In a column-primary format, these pseudo-classes match against row associations instead.

15.1. Column combinator

The column combinator, which consists of two pipes (||) represents the relationship of a column element to a cell element belonging to the column it represents. Column membership is determined based on the semantics of the document language only: whether and how the elements are presented is not considered. If a cell element belongs to more than one column, it is represented by a selector indicating membership in any of those columns.

The following example makes cells C, E, and G gray.
col.selected || td {
  background: gray;
  color: white;
  font-weight: bold;
}
<table>
  <col span="2">
  <col class="selected">
  <tr><td>A <td>B <td>C
  <tr><td colspan="2">D <td>E
  <tr><td>F <td colspan="2">G
</table>

15.2. :nth-column() pseudo-class

The :nth-column(An+B) pseudo-class notation represents a cell element belonging to a column that has An+B-1 columns before it, for any positive integer or zero value of n. Column membership is determined based on the semantics of the document language only: whether and how the elements are presented is not considered. If a cell element belongs to more than one column, it is represented by a selector indicating any of those columns.

The CSS Syntax Module [CSS3SYN] defines the An+B notation.

15.3. :nth-last-column() pseudo-class

The :nth-last-column(An+B) pseudo-class notation represents a cell element belonging to a column that has An+B-1 columns after it, for any positive integer or zero value of n. Column membership is determined based on the semantics of the document language only: whether and how the elements are presented is not considered. If a cell element belongs to more than one column, it is represented by a selector indicating any of those columns.

The CSS Syntax Module [CSS3SYN] defines the An+B notation.

16. Calculating a selector’s specificity

A selector’s specificity is calculated for a given element as follows:

If the selector is a selector list, this number is calculated for each selector in the list, and the specificity of the entire selector is the largest of any individual selector in the list that matches the element.

A few pseudo-classes provide "evaluation contexts" for other selectors, and so have their specificity defined by their contents and how they match:

For example:

Specificities are compared by comparing the three components in order: the specificity with a larger A value is more specific; if the two A values are tied, then the specificity with a larger B value is more specific; if the two B values are also tied, then the specificity with a larger C value is more specific; if all the values are tied, the two specifities are equal.

Due to storage limitations, implementations may have limitations on the size of A, B, or C. If so, values higher than the limit must be clamped to that limit, and not overflow.

Examples:
*               /* a=0 b=0 c=0 */
LI              /* a=0 b=0 c=1 */
UL LI           /* a=0 b=0 c=2 */
UL OL+LI        /* a=0 b=0 c=3 */
H1 + *[REL=up]  /* a=0 b=1 c=1 */
UL OL LI.red    /* a=0 b=1 c=3 */
LI.red.level    /* a=0 b=2 c=1 */
#x34y           /* a=1 b=0 c=0 */
#s12:not(FOO)   /* a=1 b=0 c=1 */
.foo :matches(.bar, #baz)
                /* Either a=1 b=1 c=0
                   or a=0 b=2 c=0, depending
                   on the element being matched. */

Note: Repeated occurrences of the same simple selector are allowed and do increase specificity.

Note: The specificity of the styles specified in an HTML style attribute is described in CSS Style Attributes. [CSSSTYLEATTR]

17. Grammar

Selectors are parsed according to the following grammar:

<selector-list> = <complex-selector-list>

<complex-selector-list> = <complex-selector>#

<compound-selector-list> = <compound-selector>#

<simple-selector-list> = <simple-selector>#

<relative-selector-list> = <relative-selector>#

<complex-selector> = <compound-selector> [ <combinator>? <compound-selector> ]*

<relative-selector> = <combinator>? <complex-selector>

<combinator> = '>>' | '>' | '+' | '~' | <column-token>

<compound-selector> = <simple-selector>+

<simple-selector> = <type-selector> | <id-selector> |
                    <class-selector> | <attribute-selector> |
                    <pseudo-class-selector> | <pseudo-element-selector>

<type-selector> = <wq-name> | <ns-prefix> '*'

<ns-prefix> = [ <ident-token> | '*' ]? '|'

<wq-name> = <ns-prefix>? <ident-token>

<id-selector> = <hash-token>

<class-selector> = '.' <ident-token>

<attribute-selector> = '[' <wq-name> ']' |
                       '[' <wq-name> <attr-matcher> [ <string-token> | <ident-token> ] <attr-modifier>? ']'

<attr-matcher> = '=' | <include-match-token> | <dash-match-token> | <prefix-match-token> |
                 <suffix-match-token> | <substring-match-token>

<attr-modifier> = i

<pseudo-class-selector> = ':' <ident-token> |
                          ':' <function-token> <any-value> ')'

<pseudo-element-selector> = ':' <pseudo-class-selector>

In addition to the above grammar, the following rules apply:

Should I consider the "only one pseudo-element per complex selector, at the end of the last compound selector" rule now trashed? In practice, all implementations violate that rule to at least some extent.

Note: The grammar above states that a combinator is optional between two <compound-selector>s in a <complex-selector>. This is only for grammatical purposes, as the CSS Value Definition Syntax’s lax treatment of whitespace makes it difficult to indicate that a grammar term can be whitespace. "Omitting" a combinator is actually just specifying the descendant combinator.

18. API Hooks

To aid in the writing of specs that use Selectors concepts, this section defines several API hooks that can be invoked by other specifications.

18.1. Evaluating a Selector

This section describes how to evaluate a selector against a set of elements.

APIs using this algorithm must provide a selector, and one or more root elements indicating the trees that will be searched by the selector. All of the root elements must share the same root, or else calling this algorithm is invalid.

Callers may optionally provide:

A selector is evaluated against some initial list of elements: the selector match list. The selector match list is initially populated with the root elements provided to the algorithm, and all their descendants.

The selector is processed from left to right in order, with simple selectors filtering the selector match list, and combinators and pseudo-elements changing the selector match list into something new.

If the selector is scoped, then after the selector is finished processing, the selector match list must be filtered to contain only elements that are descendants of the scoping root.

After the selector is finished matching, the selector match list must be filtered to only contain elements and pseudo-elements allowed by the invoker of this algorithm.

When this process is done, the elements in the selector match list are the elements said to match the selector. If the order of elements matter, they must be sorted in shadow-including tree order, unless otherwise specified.

For example, to evaluate the selector "div > i.name" against a document, the selector match list is first set to all the elements in the entire document. Then, the "div" type selector is evaluated, filtering the selector match list to only contain elements with a tagname of "div". Then, the ">" child combinator is evaluated, transforming the selector match list by replacing each element currently in it with the element’s children. Then, the "i" type selector is evaluated, filtering the selector match list to only contain elements with a tagname of "i". Finally, the ".name" class selector is evaluated, filtering the selector match list to only contain elements with a class of "name".

Note: Many implementations of selectors instead evaluate them right to left, as it’s more efficient to do so in many cases. This, as usual, is completely valid, as long as it results in the same elements being returned as the spec’s algorithm would.

The relative position of pseudo-elements in the selector match list is undefined. There’s not yet a context that exposes this information, but we need to decide on something eventually, before something is exposed.

18.2. Parse A Selector

This section defines how to parse a selector from a string source. It returns either a complex selector list, or failure.

  1. Let selector be the result of parsing source as a <selector-list>. If it does not match the grammar, return failure.
  2. Otherwise, if any simple selectors in selector are not recognized by the user agent, or selector is otherwise invalid in some way (such as, for example, containing an undeclared namespace prefix), return failure.
  3. Otherwise, return selector.

18.3. Parse A Relative Selector

This section defines how to parse a relative selector from a string source, against :scope elements refs. It returns either a complex selector list, or failure.

  1. Let selector be the result of parsing source as a <relative-selector-list>. If it does not match the grammar, return failure.
  2. Otherwise, if any simple selectors in selector are not recognized by the user agent, or selector is otherwise invalid in some way (such as, for example, containing an undeclared namespace prefix), return failure.
  3. Otherwise, absolutize selector with refs as the :scope elements.
  4. Return selector.

18.4. Match a Selector Against A Tree

This section defines how to match a selector against a tree.

APIs calling this algorithm must provide a selector, and a set of root elements of the trees to be matched against. They may optionally provide:

This algorithm returns a (possible empty) list of elements.

  1. Evaluate a selector with the same arguments provided to this algorithm, and return the result.

18.5. Match a Selector Against an Element

This section defines how to match a selector against an element.

APIs calling this algorithm must provide a selector and an element. They may optionally provide the same optional arguments as described in the algorithm to match a selector against a tree.

This algorithm returns either success or failure.

  1. Let root element be the "root ancestor" of element: the element found by traversing parent links from element until an element without a parent is encountered.
  2. Evaluate a selector with selector and root element, and any optional arguments passed to this algorithm. Let matched elements be the result.
  3. If element is in matched elements, return success. Otherwise, return failure.

19. Appendix A: Guidance on Mapping Source Documents & Data to an Element Tree

This section is informative.

The element tree structure described by the DOM is powerful and useful, but generic enough to model pretty much any language that describes tree-based data (or even graph-based, with a suitable interpretation).

Some languages, like HTML, already have well-defined procedures for producing a DOM object from a resource. If a given language does not, such a procedure must be defined in order for Selectors to apply to documents in that language.

At minimum, the document language must define what maps to the DOM concept of an "element".

The primary one-to-many relationship between nodes—parent/child in tree-based structures, element/neighbors in graph-based structures—should be reflected as the child nodes of an element.

Other features of the element should be mapped to something that serves a similar purpose to the same feature in DOM:

type
If the elements in the document language have some notion of "type" as a basic distinguisher between different groups of elements, it should be reflected as the "type" feature.

If this "type" can be separated into a "basic" name and a "namespace" that groups names into higher-level groups, the latter should be reflected as the "namespace" feature. Otherwise, the element shouldn’t have a "namespace" feature, and the entire name should be reflected as the "type" feature.

id
If some aspect of the element functions as a unique identifier across the document, it should be mapped to the "id" feature.

Note: While HTML only allows an element to have a single ID, this should not be taken as a general restriction. The important quality of an ID is that each ID should be associated with a single element; a single element can validly have multiple IDs.

classes and attributes
Aspects of the element that are useful for identifying the element, but are not generally unique to elements within a document, should be mapped to the "class" or "attribute" features depending on if they’re something equivalent to a "label" (a string by itself) or a "property" (a name/value pair)
pseudo-classes and pseudo-attributes
If any elements match any pseudo-classes or have any pseudo-elements, that must be explicitly defined.

Some pseudo-classes are *syntactical*, like :has() and :matches(), and thus should always work. Need to indicate that somewhere. Probably the structural pseudos always work whenever the child list is ordered.

For example, JSONSelect is a library that uses selectors to extract information from JSON documents.

This structure is sufficient to allow powerful, compact querying of JSON documents with selectors.

20. Changes

Significant changes since the 2 May 2013 Working Draft include:

21. Acknowledgements

The CSS working group would like to thank everyone who contributed to the previous Selectors specifications over the years, as those specifications formed the basis for this one. In particular, the working group would like to extend special thanks to the following for their specific contributions to Selectors Level 4: L. David Baron, Andrew Fedoniouk, Ian Hickson, Grey Hodge, Lachlan Hunt, Jason Cranford Teague

22. Privacy and Security Considerations

This specification introduces no new privacy or security considerations, as selectors do not provide any ability not already possible by walking the DOM manually.

Conformance

Document conventions

Conformance requirements are expressed with a combination of descriptive assertions and RFC 2119 terminology. The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this document are to be interpreted as described in RFC 2119. However, for readability, these words do not appear in all uppercase letters in this specification.

All of the text of this specification is normative except sections explicitly marked as non-normative, examples, and notes. [RFC2119]

Examples in this specification are introduced with the words “for example” or are set apart from the normative text with class="example", like this:

This is an example of an informative example.

Informative notes begin with the word “Note” and are set apart from the normative text with class="note", like this:

Note, this is an informative note.

Advisements are normative sections styled to evoke special attention and are set apart from other normative text with <strong class="advisement">, like this: UAs MUST provide an accessible alternative.

Conformance classes

Conformance to this specification is defined for three conformance classes:

style sheet
A CSS style sheet.
renderer
A UA that interprets the semantics of a style sheet and renders documents that use them.
authoring tool
A UA that writes a style sheet.

A style sheet is conformant to this specification if all of its statements that use syntax defined in this module are valid according to the generic CSS grammar and the individual grammars of each feature defined in this module.

A renderer is conformant to this specification if, in addition to interpreting the style sheet as defined by the appropriate specifications, it supports all the features defined by this specification by parsing them correctly and rendering the document accordingly. However, the inability of a UA to correctly render a document due to limitations of the device does not make the UA non-conformant. (For example, a UA is not required to render color on a monochrome monitor.)

An authoring tool is conformant to this specification if it writes style sheets that are syntactically correct according to the generic CSS grammar and the individual grammars of each feature in this module, and meet all other conformance requirements of style sheets as described in this module.

Requirements for Responsible Implementation of CSS

The following sections define several conformance requirements for implementing CSS responsibly, in a way that promotes interoperability in the present and future.

Partial Implementations

So that authors can exploit the forward-compatible parsing rules to assign fallback values, CSS renderers must treat as invalid (and ignore as appropriate) any at-rules, properties, property values, keywords, and other syntactic constructs for which they have no usable level of support. In particular, user agents must not selectively ignore unsupported property values and honor supported values in a single multi-value property declaration: if any value is considered invalid (as unsupported values must be), CSS requires that the entire declaration be ignored.

Implementations of Unstable and Proprietary Features

To avoid clashes with future stable CSS features, the CSSWG recommends following best practices for the implementation of unstable features and proprietary extensions to CSS.

Implementations of CR-level Features

Once a specification reaches the Candidate Recommendation stage, implementers should release an unprefixed implementation of any CR-level feature they can demonstrate to be correctly implemented according to spec, and should avoid exposing a prefixed variant of that feature.

To establish and maintain the interoperability of CSS across implementations, the CSS Working Group requests that non-experimental CSS renderers submit an implementation report (and, if necessary, the testcases used for that implementation report) to the W3C before releasing an unprefixed implementation of any CSS features. Testcases submitted to W3C are subject to review and correction by the CSS Working Group.

Further information on submitting testcases and implementation reports can be found from on the CSS Working Group’s website at http://www.w3.org/Style/CSS/Test/. Questions should be directed to the public-css-testsuite@w3.org mailing list.

Index

Terms defined by this specification

Terms defined by reference

References

Normative References

[CSS-DISPLAY-3]
Tab Atkins Jr.; Elika Etemad. CSS Display Module Level 3. URL: http://dev.w3.org/csswg/css-display/
[CSS-PSEUDO-4]
Daniel Glazman; Elika Etemad; Alan Stearns. CSS Pseudo-Elements Module Level 4. URL: https://drafts.csswg.org/css-pseudo-4/
[CSS-VALUES-3]
Tab Atkins Jr.; Elika Etemad. CSS Values and Units Module Level 3. 29 September 2016. CR. URL: https://www.w3.org/TR/css-values-3/
[CSS-WRITING-MODES-3]
Elika Etemad; Koji Ishii. CSS Writing Modes Level 3. URL: http://dev.w3.org/csswg/css-writing-modes-3/
[CSS21]
Bert Bos; et al. Cascading Style Sheets Level 2 Revision 1 (CSS 2.1) Specification. 7 June 2011. REC. URL: https://www.w3.org/TR/CSS2
[CSS3NAMESPACE]
Elika Etemad. CSS Namespaces Module Level 3. URL: http://dev.w3.org/csswg/css-namespaces/
[CSS3SYN]
Tab Atkins Jr.; Simon Sapin. CSS Syntax Module Level 3. URL: http://dev.w3.org/csswg/css-syntax/
[CSS3TEXT]
Elika Etemad; Koji Ishii. CSS Text Module Level 3. URL: http://dev.w3.org/csswg/css-text-3/
[DOM]
Anne van Kesteren. DOM Standard. Living Standard. URL: https://dom.spec.whatwg.org/
[HTML]
Anne van Kesteren; et al. HTML Standard. Living Standard. URL: https://html.spec.whatwg.org/multipage/
[INFRA]
Anne van Kesteren; Domenic Denicola. Infra Standard. Living Standard. URL: https://infra.spec.whatwg.org/
[RFC2119]
S. Bradner. Key words for use in RFCs to Indicate Requirement Levels. March 1997. Best Current Practice. URL: https://tools.ietf.org/html/rfc2119
[SELECT]
Tantek Çelik; et al. Selectors Level 3. 29 September 2011. REC. URL: https://www.w3.org/TR/css3-selectors/
[SVG2]
Nikos Andronikos; et al. Scalable Vector Graphics (SVG) 2. URL: https://svgwg.org/svg2-draft/
[WHATWG-URL]
Anne van Kesteren. URL Standard. Living Standard. URL: https://url.spec.whatwg.org/

Informative References

[BCP47]
A. Phillips; M. Davis. Tags for Identifying Languages. September 2009. IETF Best Current Practice. URL: https://tools.ietf.org/html/bcp47
[CSS-SCOPING-1]
Tab Atkins Jr.; Elika Etemad. CSS Scoping Module Level 1. URL: http://dev.w3.org/csswg/css-scoping/
[CSS3UI]
Tantek Çelik; Florian Rivoal. CSS Basic User Interface Module Level 3 (CSS3 UI). URL: http://dev.w3.org/csswg/css-ui/
[CSSSTYLEATTR]
Tantek Çelik; Elika Etemad. CSS Style Attributes. URL: http://dev.w3.org/csswg/css-style-attr/
[HTML401]
Dave Raggett; Arnaud Le Hors; Ian Jacobs. HTML 4.01 Specification. 24 December 1999. REC. URL: https://www.w3.org/TR/html401
[HTML5]
Ian Hickson; et al. HTML5. URL: https://www.w3.org/html/wg/drafts/html/master/
[MATHML]
Patrick D F Ion; Robert R Miner. Mathematical Markup Language (MathML) 1.01 Specification. 7 July 1999. REC. URL: https://www.w3.org/TR/MathML/
[RFC4647]
A. Phillips; M. Davis. Matching of Language Tags. September 2006. Best Current Practice. URL: https://tools.ietf.org/html/rfc4647
[SVG11]
Erik Dahlström; et al. Scalable Vector Graphics (SVG) 1.1 (Second Edition). 16 August 2011. REC. URL: https://www.w3.org/TR/SVG11/
[XFORMS11]
John Boyer. XForms 1.1. 20 October 2009. REC. URL: https://www.w3.org/TR/xforms11/
[XML-NAMES]
Tim Bray; et al. Namespaces in XML 1.0 (Third Edition). 8 December 2009. REC. URL: https://www.w3.org/TR/xml-names
[XML10]
Tim Bray; et al. Extensible Markup Language (XML) 1.0 (Fifth Edition). 26 November 2008. REC. URL: https://www.w3.org/TR/xml

Issues Index

The categorization of things into the "dynamic" or "static" profiles needs implementor review. If some things currently not in the dynamic profile can reasonably be done in CSS Selectors, we should move them.
Can we make this less wishy-washy by saying that a complex selector “represents” its last compound selector? Or do we need to have a + b “represent” both an "a" and a "b" in a sibling relationship?
Pseudo-elements aren’t handled here, and should be.
Clarify that :not() and :matches() can be used when containing abovementioned pseudos.
Does ::first-line:not(:focus) match anything?
Add comma-separated syntax for multiple-value matching? e.g. [rel ~= next, prev, up, first, last]
Any better name suggestions for this pseudo?
Turn this scenario into an example.
Cross-check with :-moz-ui-invalid.
Add :-moz-ui-valid as :user-valid per WG resolution.
Evaluate proposed :dirty pseudo-class
Clarify that this (and :invalid/:valid) can apply to form and fieldset elements.
We don’t like the name :blankit doesn’t clearly convey a difference from :empty. Moz uses :-moz-whitespace-only, which is clear but a little wordy. Any other suggestions?
Should I consider the "only one pseudo-element per complex selector, at the end of the last compound selector" rule now trashed? In practice, all implementations violate that rule to at least some extent.
The relative position of pseudo-elements in the selector match list is undefined. There’s not yet a context that exposes this information, but we need to decide on something eventually, before something is exposed.
Some pseudo-classes are *syntactical*, like :has() and :matches(), and thus should always work. Need to indicate that somewhere. Probably the structural pseudos always work whenever the child list is ordered.