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:
- directly on an element to test whether it matches some criteria,
such as in the
element.matches()
function defined in [DOM] - applied to an entire tree of elements
to filter it into a set of elements that match the criteria,
such as in the
document.querySelectorAll()
function defined in [DOM] or the selector of a CSS style rule. - used "in reverse" to generate markup that would match a given selector, such as in HAML or Emmet.
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 (Matches-None) Pseudo-class: :not() | 3/4 |
E:is(s1, s2, …)
| an E element that matches compound selector s1 and/or compound selector s2 | § 4.2 The Matches-Any Pseudo-class: :is() | 4 |
E:where(s1, s2, …)
| an E element that matches compound selector s1 and/or compound selector s2 but contributes no specificity. | § 4.4 The Specificity-adjustment Pseudo-class: :where() | 4 |
E:has(rs1, rs2, …)
| an E element, if there exists an element that matches either of the relative selectors rs1 or rs2, when evaluated with E as the anchor elements | § 4.5 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.1 Attribute presence and value selectors | 2 |
E[foo="bar"]
| an E element whose foo attribute value is
exactly equal to bar
| § 6.1 Attribute presence and value 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" s]
| an E element whose foo attribute value is identical to 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.1 Attribute presence and value 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.1 Attribute presence and value selectors | 2 |
E:dir(ltr)
| an element of type E 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 otherwise 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:local-link
| an E element being the source anchor of a hyperlink targeting the current URL | § 8.3 The Local Link Pseudo-class: :local-link | 4 |
E:target
| an E element being the target of the current URL | § 8.4 The Target Pseudo-class: :target | 3 |
E:target-within
| an E element that is the target of the current URL or contains an element that does. | § 8.5 The Target Container Pseudo-class: :target-within | 4 |
E:scope
| an E element being a scoping root | § 8.6 The Reference Element Pseudo-class: :scope | 4 |
E:current
| an E element that is currently presented in a time-dimensional canvas | § 10.1 The Current-element Pseudo-class: :current | 4 |
E:current(s)
| an E element that is the deepest :current element that matches selector s | § 10.1 The Current-element Pseudo-class: :current | 4 |
E:past
| an E element that is in the past in a time-dimensional canvas | § 10.2 The Past-element Pseudo-class: :past | 4 |
E:future
| an E element that is in the future in a time-dimensional canvas | § 10.3 The Future-element Pseudo-class: :future | 4 |
E:active
| an E element that is in an activated state | § 9.2 The Activation Pseudo-class: :active | 1 |
E:hover
| an E element that is under the cursor, or that has a descendant under the cursor | § 9.1 The Pointer Hover Pseudo-class: :hover | 2 |
E:focus
| an E element that has user input focus | § 9.3 The Input Focus Pseudo-class: :focus | 2 |
E:focus-within
| an E element that has user input focus or contains an element that has input focus. | § 9.5 The Focus Container Pseudo-class: :focus-within | 4 |
E:focus-visible
| 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.4 The Focus-Indicated Pseudo-class: :focus-visible | 4 |
E:enabled
| a user interface element E that is enabled or disabled, respectively | § 13.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 | § 13.1.2 The Mutability Pseudo-classes: :read-only and :read-write | 3-UI/4 |
E:placeholder-shown
| an input control currently showing placeholder text | § 13.1.3 The Placeholder-shown Pseudo-class: :placeholder-shown | 3-UI/4 |
E:default
| a user interface element E that is the default item in a group of related choices | § 13.1.5 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) | § 13.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) | § 13.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 | § 13.3.2 The Validity Pseudo-classes: :valid and :invalid | 3-UI/4 |
E:in-range E:out-of-range
| a user-input element E whose value is in-range/out-of-range | § 13.3.3 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 | § 13.3.4 The Optionality Pseudo-classes: :required and :optional | 3-UI/4 |
E:blank
| a user-input element E whose value is blank (empty/missing) | § 13.3.1 The Empty-Value Pseudo-class: :blank | 4 |
E:user-invalid
| a user-altered user-input element E with incorrect input (invalid, out-of-range, omitted-but-required) | § 13.3.5 The User-interaction Pseudo-classes: :user-valid and :user-invalid | 4 |
E:root
| an E element, root of the document | § 14.1 :root pseudo-class | 3 |
E:empty
| an E element that has no children (neither elements nor text) except perhaps white space | § 14.2 :empty pseudo-class | 3 |
E:nth-child(n [of S]?)
| an E element, the n-th child of its parent matching S | § 14.3.1 :nth-child() pseudo-class | 3/4 |
E:nth-last-child(n [of S]?)
| an E element, the n-th child of its parent matching S, counting from the last one | § 14.3.2 :nth-last-child() pseudo-class | 3/4 |
E:first-child
| an E element, first child of its parent | § 14.3.3 :first-child pseudo-class | 2 |
E:last-child
| an E element, last child of its parent | § 14.3.4 :last-child pseudo-class | 3 |
E:only-child
| an E element, only child of its parent | § 14.3.5 :only-child pseudo-class | 3 |
E:nth-of-type(n)
| an E element, the n-th sibling of its type | § 14.4.1 :nth-of-type() pseudo-class | 3 |
E:nth-last-of-type(n)
| an E element, the n-th sibling of its type, counting from the last one | § 14.4.2 :nth-last-of-type() pseudo-class | 3 |
E:first-of-type
| an E element, first sibling of its type | § 14.4.3 :first-of-type pseudo-class | 3 |
E:last-of-type
| an E element, last sibling of its type | § 14.4.4 :last-of-type pseudo-class | 3 |
E:only-of-type
| an E element, only sibling of its type | § 14.4.5 :only-of-type pseudo-class | 3 |
E F
| an F element descendant of an E element | § 15.1 Descendant combinator ( ) | 1 |
E > F
| an F element child of an E element | § 15.2 Child combinator (>) | 2 |
E + F
| an F element immediately preceded by an E element | § 15.3 Next-sibling combinator (+) | 2 |
E ~ F
| an F element preceded by an E element | § 15.4 Subsequent-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 | § 16.1 Column combinator (||) | 4 |
E:nth-col(n)
| an E element that represents a cell belonging to the nth column in a grid/table | § 16.2 :nth-col() pseudo-class | 4 |
E:nth-last-col(n)
| an E element that represents a cell belonging to the nth column in a grid/table, counting from the last one | § 16.3 :nth-last-col() pseudo-class | 4 |
Note: Some Level 4 selectors (noted above as "3-UI") were introduced in [CSS3UI].
3. Selector Syntax and Structure
3.1. Structure and Terminology
A selector represents a particular pattern of element(s) in a tree structure. The term selector can refer to a simple selector, compound selector, complex selector, or selector list. The subject of a selector is any element that selector is defined to be about; that is, any element matching that selector.
A simple selector is a single condition on an element.
A type selector, universal selector, attribute selector, class selector, ID selector,
or pseudo-class is a simple selector.
(It is represented by
A compound selector is a sequence of simple selectors that are not separated by a combinator,
and represents a set of simultaneous conditions on a single element.
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.
(A compound selector is represented by
Note: As whitespace represents the descendant combinator, no whitespace is allowed between the simple selectors in a compound selector.
A combinator is a condition of relationship between two elements
represented 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 subsequent-sibling combinator (U+007E, ~
).
Two given elements are said to match a combinator when the condition of relationship between these elements is true.
A complex selector is
a sequence of one or more compound selectors separated by combinators.
It represents a set of simultaneous conditions
on a set of elements in the particular relationships
described by its combinators.
(Complex selectors are represented by
Note: Thus, a selector consisting of a single compound selector matches any element satisfying the requirements of its constituent simple selectors. Prepending another compound selector and a combinator to a sequence imposes additional matching constraints, such that the subjects of a complex selector are always a subset of the elements represented by its last compound selector.
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 additional information on selector lists and the various <*-selector-list> productions in the grammar for their formal syntax.) A given element is said to match a selector list when it matches any (at least one) of the selectors in that selector list.
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:
- The element’s type (also known as its tag name).
- The element’s namespace.
- An ID.
- Classes (named groups) to which it belongs.
- Attributes, which are name-value pairs.
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]
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.
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.)
querySelector()
method defined in [DOM] allows the author to evaluate a scoped selector
relative to the element it’s called on.
A call like widget
will thus only find a
elements inside of the widget
element,
ignoring any other a
s that might be scattered throughout the document.
3.4. Relative Selectors
Certain contexts may accept relative selectors, which are a shorthand for selectors that represent elements relative to one or more relative selector anchor elements. Relative selectors begin with a combinator, with a selector representing the anchor element implied at the start of the selector. (If no combinator is present, the descendant combinator is implied.)
Relative selectors are represented by
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.
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 for 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 *.
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 :is() can be used when containing above-mentioned pseudos.
Does ::first-line:not(:focus) match anything?
Notice that ::first-line:hover 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. Sub-pseudo-elements
Some pseudo-elements are able to be the originating element of other pseudo-elements, which are defined as the sub-pseudo-elements of this originating pseudo-element. For example, when ::before is given a list-item display type, it becomes the originating pseudo-element of its ::before::marker sub-pseudo-element.
Where disambiguation is needed, the term ultimate originating element refers to the real (non-pseudo) element from which a pseudo-element originates.
Unless the corresponding sub-pseudo-element is explicitly defined to exist in another specification, pseudo-element selectors are not valid when compounded to another pseudo-element selector. So, for example, ::before::before is an invalid selector, but ::before::marker is valid (in implementations that support the ::before::marker sub-pseudo-element).
3.6.5. 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.
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. However, at least in CSS, their rendering must be defined so as to maintain the tree-ness of the box tree.
foo <"shadow root">"shadow root">
the selectors div > span and div::shadow ::slotted > span select the same element via different paths.
However, when rendered,
the All Selectors syntax is ASCII case-insensitive (i.e. [a-z] and [A-Z] are equivalent),
except for the parts
that are not under the control of Selectors:
specifically,
the case-sensitivity of
document language element names,
attribute names,
and attribute values
depends on the document language. 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).
Other space-like code points, such as EM SPACE (U+2003) and
IDEOGRAPHIC SPACE (U+3000), are never considered syntactic 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 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 @namespace rule. [CSS3NAMESPACE] User agents must observe the rules for handling invalid selectors: Note: Consistent with CSS’s forwards-compatible parsing principle,
UAs must treat as invalid any pseudo-classes, pseudo-elements, combinators, or other syntactic constructs
for which they have no usable level of support.
See Partial implementations. An invalid selector represents, and therefore matches, nothing. Some selectors have a legacy selector alias.
This is a name which, at parse time, is converted to the standard name
(and thus does not appear anywhere in any object model representing the selector). 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. is equivalent to: 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. is not equivalent to: 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.) The matches-any pseudo-class, :is(),
is a functional pseudo-class taking a If the argument, after parsing, is an empty list,
the pseudo-class is valid but matches nothing.
Otherwise, the pseudo-class matches any element
that matches any of the selectors in the list. Note: The specificity of the :is() pseudo-class
is replaced by the specificity of its most specific argument.
Thus, a selector written with :is() does not necessarily have equivalent specificity
to the equivalent selector written without :is() For example, if we have :is(ul, ol, .list) > [hidden] and ul > [hidden], ol > [hidden], .list > [hidden] a [hidden] child of an Pseudo-elements cannot be represented by the matches-any pseudo-class;
they are not valid within :is(). Default namespace declarations do not affect the compound selector representing the subject of any selector
within a :is() pseudo-class,
unless that compound selector contains
an explicit universal selector or type selector. 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 :is() notation: As previous drafts of this specification
used the name :matches() for this pseudo-class,
UAs may additionally implement this obsolete name
as a legacy selector alias for :is() if needed for backwards-compatibility. 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(). Note: The specificity of the :not() pseudo-class
is replaced by the specificity of the most specific selector in its argument;
thus it has the exact behavior of :not(:is(argument)).
See § 17 Calculating a selector’s specificity. Pseudo-elements cannot be represented by the negation pseudo-class;
they are not valid within :not(). The following selector represents all but FOO elements. The following compound selector represents all HTML elements
except links. As with :is(),
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 :is() 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. The Specificity-adjustment pseudo-class, :where(),
is a functional pseudo-class
with the same syntax and functionality as :is().
Unlike :is(), neither the :where() pseudo-class, nor any of its arguments,
contribute to the specificity of the selector— This is useful for introducing filters in a selector
while keeping the associated style declarations easy to override. However, by using :where() the author can explicitly declare their intent: Note: Future levels of Selectors may introduce an additional argument
to explicitly set the specificity of that instance of the pseudo-class. The relational pseudo-class, :has(),
is a functional pseudo-class taking a The :has() pseudo-class cannot be nested; :has() is not valid within :has().
Also, unless explicitly defined as a :has-allowed pseudo-element, pseudo-elements are not valid selectors within :has().
(This specification does not define any :has-allowed pseudo-elements,
but other specifications may do so.) Note: Pseudo-elements are generally excluded from :has() because
many of them exist conditionally, based on the styling of their ancestors,
so allowing these to be queried by :has() would introduce cycles. The following selector matches a The following selector matches Note that ordering matters in the above selector.
Swapping the nesting of the two pseudo-classes, like: ...would result in matching any A type selector is the name of a document language element type,
and represents an instance of that element type in the document tree. 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.) The universal selector is a special type selector,
that represents an element of any element type. It is written as a CSS qualified name with an asterisk ( 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. 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” ( 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. 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. In some host languages,
elements can have a distinction between being “defined”/“constructed” or not.
The :defined pseudo-class matches elements
that are fully defined,
as dictated by the host language. If the host language does not have this sort of distinction,
all elements in it match :defined. Custom elements, on the other hand,
start out undefined,
and only become defined when properly registered.
This means the :defined pseudo-class
can be used to hide a custom element
until it has been registered: 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] CSS2 introduced four attribute selectors: Attribute values must be The following attribute selector represents an h1 element
that carries the In the following example, the selector represents a span element whose 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 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 The following selector represents an a element
whose The following selector represents an a element for
which the value of the The following selectors represent a DIALOGUE element
whenever it has one of two different values for an attribute Three additional attribute selectors are provided for matching
substrings in the value of an attribute: Attribute values must be The following selector represents an HTML a element
with an The following selector represents an HTML paragraph
with a By default case-sensitivity of attribute names and values in selectors
depends on the document language. To match attribute values ASCII case-insensitively regardless of document language rules,
the attribute selector may include the identifier Alternately, the attribute selector may include the identifier Like the rest of Selectors syntax,
the Note: Some document models normalize case-insensitive attribute values at parse time
such that checking if a string is case-sensitive matching is impossible.
Case-sensitive matching via 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" ( An attribute selector with an attribute name containing a namespace
prefix that has not been previously declared is
an invalid selector. The first rule will match only elements with the attribute The second rule will match only elements with the attribute The last two rules are equivalent and will match only elements
with the attribute 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 behavior
of non-validating processors as defined by the XML specification. Consider an element If the style sheet contains the rules the first rule might not match elements whose 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 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 We can assign style information to all elements with or just The following assigns style only to H1 elements with Given these rules, the first The following rule matches any P element whose This rule matches when 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,
only matching class names they are identical to. [INFRA] 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 An ID selector consists of a “number sign” (U+0023, The following ID selector represents any element whose ID-typed
attribute has the value "chapter1": The following selector represents any element whose ID-typed
attribute has the value "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,
only matching IDs they are identical to. [INFRA] 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 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 ( 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 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 content language.
The :lang() pseudo-class,
which accepts a comma-separated list of one or more language ranges,
represents an element whose content language is one of the languages listed in its argument.
Each language range in :lang() must be a valid CSS Note: The content language of an element is defined by the document language.
For example, in HTML [HTML5], the content language is determined
by a combination of the An element’s content language matches a language range if,
when represented in BCP 47 syntax [BCP47],
it matches that language range in an extended filtering operation per [RFC4647] Matching of Language Tags (section 3.3.2).
For this purpose, a wildcard language range ( A language range consisting of an empty string
(:lang(""))
matches (only) elements whose language is not tagged. Note: It is recommended that documents and protocols
indicate language using codes from [BCP47] or its successor,
and in the case of XML-based formats, by means of 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. Je suis français. 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. To select against an element’s lang attribute value
using this type of language range match,
use both the attribute selector and language pseudo-class together,
e.g. [lang]:lang(de-DE). Note: Wildcard language matching and comma-separated lists are new in Level 4. The :any-link pseudo-class represents an element
that acts as the source anchor of a hyperlink.
For example, in [HTML5],
any 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. 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. The :local-link pseudo-class
allows authors to style hyperlinks based on the users current location within a site.
It represents an element that is
the source anchor of a hyperlink whose target’s absolute URL
matches the element’s own document URL.
If the hyperlink’s target includes a fragment URL,
then the fragment URL of the current URL must also match;
if it does not, then the fragment URL portion of the current URL
is not taken into account in the comparison. Note: The current URL of a page can change as a result of user actions
such as activating a link targeting a different fragment within the same page;
or by use of the 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. 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. This selector represents a The :target-within pseudo-class
applies to any element to which the :target pseudo class applies
as well as to any element whose descendant in the flat tree (including non-element nodes, such as text nodes)
matches the conditions for matching :target. In some contexts, selectors are matched
with respect to one or more scoping roots,
such as when calling the If there is no scoping root then :scope 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 their scoping root(s). A virtual scoping root is some object representing the root of a document fragment,
and can be used in selector patterns to represent other elements’ relationships
to this scoping root,
acting as the parent of any root elements in the document fragment it represents.
A virtual scoping root is featureless and cannot be the subject of the selector. However, Interactive user interfaces sometimes change the rendering in response to user actions.
Selectors provides several user action 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 can match several such pseudo-classes at the same time. An example of combining dynamic pseudo-classes: 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. 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;
the selector will simply never match in such a UA. An element also matches :hover if one of its descendants in the flat tree (including non-element nodes, such as text nodes)
matches the above conditions. Document languages may define additional ways in which an element can match :hover.
For example, [HTML5] defines a labeled control element as matching Note: Since the :hover state can apply to an element
because its child is designated by a pointing device,
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. 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 descendants in the flat tree (including non-element nodes, such as text nodes)
matches the above conditions. 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). 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, [HTML] defines a list of focusable areas. Document languages may define additional ways in which an element can match :focus,
except that the :focus pseudo class must not automatically propagate to the parent element— There’s a desire from authors to propagate :focus from a form control to its associated While the :focus pseudo-class always matches the currently-focused element,
UAs only sometimes visibly indicate focus (such as by drawing a “focus ring”),
instead using a variety of heuristics
to visibly indicate the focus only when it would be most helpful to the user.
The :focus-visible pseudo-class matches a focused element
in these situations only,
allowing authors to change the appearance of the focus indicator
without changing when a focus indicator appears. If the user has expressed a preference
(such as via a system preference or a browser setting)
to always see a visible focus indicator, indicate focus regardless of any other factors.
(Another option may be for the user agent to show its own focus indicator
regardless of author styles.) If the element which supports keyboard input
(such as an If the user interacts with the page via keyboard or some other non-pointing device, indicate focus.
(This means keyboard usage may change whether this pseudo-class matches
even if it doesn’t affect :focus). If the user interacts with the page via a pointing device (mouse, touchscreen, etc.)
and the focused element does not support keyboard input,
don’t indicate focus. If the previously-focused element indicated focus,
and a script causes focus to move elsewhere,
the newly focused element should indicate focus. Conversely, if the previously-focused element did not indicate focus,
and a script causes focus to move elsewhere,
the newly focused element should also not indicate focus. User agents should also use :focus-visible to specify the default focus style,
so that authors using :focus-visible will not also need to disable
the default :focus style. The :focus-within pseudo-class
applies to any element for which the :focus pseudo class applies
as well as to an element whose descendant in the flat tree (including non-element nodes, such as text nodes)
matches the conditions for matching :focus. 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. The :current pseudo-class represents the
element, or an ancestor of the element, that is currently being displayed. Its alternate form :current(), like :is(),
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.) 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. 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. 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. The :playing pseudo-class represents an element
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” or “stalled” state.) The :paused pseudo-class represents an element
that is capable of being “played” or “paused”,
when that element is “paused” (i.e. not ”playing”).
(This includes both an explicit “paused” state,
and other non-playing states like “loaded, hasn’t been activated yet”, etc.) The :seeking pseudo-class represents an element
that is capable of ”seeking”
when that element is ”seeking”.
(For the The :buffering pseudo-class represents an element
that is capable of being “played” or “paused”,
when that element cannot continue playing
because it is actively attempting to obtain media data but has not yet obtained enough data to resume playback.
(Note that the element is still considered to be “playing” when it is “buffering”.
Whenever :buffering matches an element, :playing also matches the element.) The :stalled pseudo-class represents an element
when that element cannot continue playing
because it is actively attempting to obtain media data but it has failed to receive any data for some amount of time.
For the The :muted pseudo-class represents
an element capable of making sound
when that element is “muted“ (forced silent).
(For the The :volume-locked pseudo-class represents
an element capable of making sound
when programmatically changing the element’s volume
does not change the element’s effective media volume. The :open pseudo-class represents an element
that has both “open” and “closed” states,
and which is currently in the “open” state. The :closed pseudo-class represents an element
that has both “open” and “closed” states,
and which is currently in the closed state. Exactly what “open” and “closed” mean is host-language specific,
but exemplified by elements such as
HTML’s Note: Being “open” or “closed” is a semantic state.
An element not currently being displayed
(for example, one that has visibility: collapse,
or belongs to a display: none subtree)
can still be “open” and will match :open. The :modal pseudo-class represents
an element which is in a state that excludes all interaction
with elements outside it until it has been dismissed.
Multiple elements can be :modal simultaneously,
with only one of them active (able to receive input). The :fullscreen pseudo-class represents
an element which is displayed in a mode that
takes up most (usually all) of the screen,
such as that defined by the Fullscreen API. [FULLSCREEN] The :picture-in-picture pseudo-class represents
an element which is displayed in a mode that
takes up most (usually all) of the viewport,
and whose viewport is confined to part of the screen
while being displayed over other content,
for example when using the Picture-in-Picture API. [picture-in-picture] The pseudo-classes in this section mostly apply to elements that take user input,
such as HTML’s input element. The :enabled pseudo-class represents
user interface elements that are in an enabled state;
such elements must have a corresponding disabled state. Conversely, the :disabled pseudo-class represents
user interface elements that are in a disabled state;
such elements must 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. 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 elements can sometimes show placeholder text
as a hint to the user on what to type in.
See, for example, the The :autofill pseudo-class represents input elements
that have been automatically filled by the user agent,
and have not been subsequently altered by the user. 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 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 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 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. The :blank pseudo-class
applies to user-input elements whose input value is empty
(consists of the empty string or otherwise null input). Note: This selector is at-risk. 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 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". 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. The :user-invalid and the :user-valid pseudo-classes
represent an element with incorrect or correct input, respectively,
but only after the user has significantly interacted with it. The :user-invalid 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. The :user-valid pseudo-class must match a :valid element 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 them 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-invalid 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. Cross-check with :-moz-ui-invalid. Evaluate proposed :dirty pseudo-class Clarify that this (and :invalid/:valid) can apply to form and fieldset elements. 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. 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). The :empty pseudo-class represents
an element that has no children
except, optionally, document white space characters.
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.
div:empty is not a valid representation of the bla :empty Note: In Level 2 and Level 3 of Selectors, :empty did not match elements that contained only white space.
This was changed so that that— 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. The :nth-child(An+B [of S]? ) pseudo-class notation represents elements that
are among An+Bth elements
from the list composed of
their inclusive siblings that match the selector list S,
which is a The An+B notation and its interpretation
are defined in CSS Syntax 3 § 6 The An+B microsyntax;
it represents any index i = An + B for any non-negative integer n. Note: For these purposes, the list of elements is 1-indexed;
that is, the first child of an element has index 1, and will be matched by :nth-child(2n+1),
because when 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. Note: The specificity of the :nth-child() pseudo-class is
the specificity of a single pseudo-class plus,
if S is specified,
the specificity of the most specific complex selector in S.
See § 17 Calculating a selector’s specificity.
Thus S:nth-child(An+B) and :nth-child(An+B of S) have the exact same specificity,
although they do differ in behavior
(see example below). Note that this is different from moving the selector outside of the function, like: This selector instead just selects the first three children
if they also happen to be "important" list items. Normally, to zebra-stripe a table’s rows,
an author would use CSS similar to the following: 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: The :nth-last-child(An+B [of S]? ) pseudo-class notation represents elements that
are among An+Bth elements
from the list composed of
their inclusive siblings that match the selector list S,
counting backwards from the end. S is Note: The specificity of the :nth-last-child() pseudo-class,
like the :nth-child() pseudo-class,
combines the specificity of a regular pseudo-class
with that of its selector argument S.
See § 17 Calculating a selector’s specificity. The CSS Syntax Module [CSS3SYN] defines the An+B notation. The :first-child pseudo-class
represents an element that if first among its inclusive siblings.
Same as :nth-child(1). This selector can represent the The last P before the note. The first P inside the note. but cannot represent the second The last P before the note. The first P inside the note. The following two selectors are usually equivalent: The :last-child pseudo-class
represents an element that is last among its inclusive siblings.
Same as :nth-last-child(1). 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. The pseudo-classes 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. The :nth-of-type(An+B) pseudo-class notation
represents the same elements that would be matched by :nth-child(|An+B| of S),
where S is a type selector and namespace prefix matching the element in question.
For example,
when considering whether an HTML 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). The :nth-last-of-type(An+B) pseudo-class notation
represents the same elements that would be matched by :nth-last-child(|An+B| of S),
where S is a type selector and namespace prefix matching the element in question.
For example,
when considering whether an HTML In this case, one could also use :not(), although the
selector ends up being just as long: The :first-of-type pseudo-class
represents the same element as :nth-of-type(1). It is a valid description for the first two The :last-of-type pseudo-class
represents the same element as :nth-last-of-type(1). The :only-of-type pseudo-class
represents the same element as :first-of-type:last-of-type. 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. A descendant combinator is whitespace that separates two compound selectors. A selector of the form A B represents an element 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: The following selector: 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 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. The following example combines descendant combinators and child
combinators. 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 For information on selecting the first child of an element,
please see the section on the :first-child pseudo-class above. 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. 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 The subsequent-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. represents a pre element following an Function a(x) has to be applied to all figures in the table. 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-col() and :nth-last-col() pseudo-classes
are defined.
In a column-primary format, these pseudo-classes match against row associations instead. 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 :nth-col(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 The CSS Syntax Module [CSS3SYN] defines the An+B notation. The :nth-last-col(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 The CSS Syntax Module [CSS3SYN] defines the An+B notation. 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.
For a given matching process against the list, the specificity in effect
is that of the most specific selector in the list that matches. A few pseudo-classes provide “evaluation contexts” for other selectors,
and so have their specificity defined specially: 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 specificities 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. Note: Repeated occurrences of the
same simple selector are allowed and do increase specificity. Note: The specificity of the styles
specified in an HTML Selectors are parsed according to the following grammar: In interpreting the above grammar,
the following rules apply: Between any of the top-level components of a Whitespace is required between two Note: A selector is also subject to a variety of more specific syntactic constraints,
and adherence to the grammar above is necessary but not sufficient for the selector to be considered valid.
See § 3.9 Invalid Selectors and Error Handling for additional rules for parsing selectors. Note: In general,
a For legacy reasons,
the general behavior of a selector list
is that if any selector in the list fails to parse
(because it uses new or UA-specific selector features, for instance),
the entire selector list becomes invalid.
This can make it hard to write CSS that uses new selectors
and still works correctly in older user agents. The Note: Style rules still use the normal, unforgiving selector list behavior. Syntactically, Parse a list of Remove all failure items from selector list,
and all items that are invalid selectors,
then return a To aid in the writing of specs that use Selectors concepts,
this section defines several API hooks that can be invoked by other specifications. Are these still necessary now that we have more rigorous definitions for match and invalid selector?
Nouns are a lot easier to coordinate across specification than predicates,
and details like the exact order of elements returned from This section defines how to parse a selector from a string source.
It returns either a complex selector list,
or failure. This section defines how to parse a relative selector from a string source.
It returns either a complex selector list,
or failure. This section defines how to match a selector against an element. APIs using this algorithm must provide a selector and an element. Callers may optionally provide: This algorithm returns either success or failure. For each complex selector in the given selector (which is taken to be a list of complex selectors),
match the complex selector against element,
as described in the following paragraph.
If the matching returns success for any complex selector,
then the algorithm return success; otherwise it returns failure. To match a complex selector against an element,
process it compound selector at a time,
in right-to-left order.
This process is defined recursively as follows: This section defines how to match a selector against a pseudo-element. APIs using this algorithm must provide a selector and a pseudo-element.
They may optionally provide the same things they may optionally provide
to the algorithm to match a selector against an element. This algorithm returns success or failure. For each complex selector in the given selector, if both: Otherwise
(that is, if this doesn’t happen for any of the complex selectors in selector),
return failure. This section defines how to match a selector against a tree. APIs using this algorithm must provide a selector,
and one or more root elements indicating the subtrees that will be searched by the selector.
All of the root elements must share the same root,
or else calling this algorithm is invalid. They may optionally provide: Only the tree-abiding pseudo-elements are really
handled in any way remotely like this. This algorithm returns a (possibly empty) list of elements. The relative position of pseudo-elements
in 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. 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— Other features of the element should be mapped
to something that serves a similar purpose to the same feature in DOM: 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. 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. Some pseudo-classes are *syntactical*,
like :has() and :is(),
and thus should always work.
Need to indicate that somewhere.
Probably the structural pseudos always work
whenever the child list is ordered. This structure is sufficient to allow powerful, compact querying of JSON documents with selectors. This appendix is normative. Due to legacy Web-compat constraints,
user agents expecting to parse Web documents must support the following features: :-webkit-autofill must be treated as a legacy selector alias of :autofill. All other pseudo-elements whose names begin with the string “-webkit-”
(matched ASCII case-insensitively)
and that are not functional notations
must be treated as valid at parse time.
(That is, ::-webkit-asdf is valid at parse time,
but ::-webkit-jkl() is not.)
If they’re not otherwise recognized and supported,
they must be treated as matching nothing, and are unknown -webkit- pseudo-elements. Unknown -webkit- pseudo-elements must be serialized in ASCII lowercase. Selectors have long had a behavior
where a single unknown/invalid selector
invalidates the entire selector list
(rather than just invalidating the one complex selector it finds itself in).
This is generally considered a legacy mistake by the WG,
but can’t be fixed at this point,
as too many stylesheets depend on this behavior,
intentionally or not. One aspect of this is that use of vendor-specific selectors
invalidates the entire selector in other user agents
that don’t recognize them,
and takes the entire style rule down with it.
This has been used intentionally in the past— In addition to this more general reasoning,
WebKit-derived user agents,
such as Safari or Chrome,
have an additional quirk related to their vendor-prefixed pseudo-elements,
where any ::-webkit--prefixed selectors are considered valid at parse time.
(This is probably a leftover quirk of an early CSS feature,
since dropped,
that intentionally treated all possible pseudo-elements as valid at parse time,
in anticipation of a feature letting authors define their own pseudo-elements.) Similar to other legacy quirks,
such as those documented in [QUIRKS],
this particular vendor-specific oddity has become common enough
that other user agents are seeing sites breaking due to them depending on it,
accidentally or not.
As such, since the quirk is in practical terms required to render the modern web correctly,
specifying it and requiring it for all user agents
ensures that today’s web pages are more likely to be correctly rendered
in user agents both current and future. As usual with quirks, however,
webpages intentionally relying on this
will be met with shaming and derision from members of the CSSWG,
and all right-thinking web developers. Significant changes since the 7 May 2022 Working Draft: Added :open and :closed pseudo-classes.
(Issue 7319) Disallowed pseudo-elements from :has() unless explicitly allowed
by the pseudo-element’s definition.
(Issue 7463) Disallowed nesting of :has().
(Issue 7344) Defined matching of ::lang("") and of elements not tagged with a language.
(Issue 6915) Untangled the concepts of "scoped" and "relative" selectors completely.
(Issue 6399) Removed "absolutize a selector" as well,
and just defined relative selector matching
in terms of the anchoring element. Reverted compound selector limitation on :nth-child().
(Issue 3760) Defined :-webkit-autofill legacy selector alias.
(Issue 7474) Significant changes since the 21 November 2018 Working Draft: Significant changes since the 2 February 2018 Working Draft: Significant changes since the 2 May 2013 Working Draft include: Note: The 1 February 2018 draft included an inadvertent commit of unfinished work;
2 February 2018 has reverted this commit (and fixed some links because why not). Significant changes since the 23 August 2012 Working Draft include: Significant changes since the 29 September 2011 Working Draft include: Additions since Level 3: 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,
Daniel Glazman,
Ian Hickson,
Grey Hodge,
Lachlan Hunt,
Anne van Kesteren,
Jason Cranford Teague,
Lea Verou This specification introduces the following privacy and security considerations: 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 Informative notes begin with the word “Note” and are set apart from the
normative text with Note, this is an informative note. Advisements are normative sections styled to evoke special attention and are
set apart from other normative text with Conformance to this specification
is defined for three conformance classes: 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. 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 component 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. 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. Once a specification reaches the Candidate Recommendation stage,
non-experimental implementations are possible, and implementors should
release an unprefixed implementation of any CR-level feature they
can demonstrate to be correctly implemented according to spec. 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 https://www.w3.org/Style/CSS/Test/.
Questions should be directed to the [email protected] mailing list. element generates boxes as if it were the child of the
element,
rather than the 3.7. Characters and case sensitivity
foo>a
.3.8. Declaring Namespace Prefixes
3.9. Invalid Selectors and Error Handling
3.10. Legacy Aliases
4. Logical Combinations
4.1. Selector Lists
h1 { font-family: sans-serif }
h2 { font-family: sans-serif }
h3 { font-family: sans-serif }
h1, h2, h3 { font-family: sans-serif }
h1 { font-family: sans-serif }
h2..foo { font-family: sans-serif }
h3 { font-family: sans-serif }
h1, h2..foo, h3 { font-family: sans-serif }
4.2. The Matches-Any Pseudo-class: :is()
ol
matches the first selector
with a specificity of (0,2,0)
whereas it matches the second selector
with a specificity of (0,1,1).
See § 17 Calculating a selector’s specificity.*|*:is(:hover, :focus)
*|*:is(*:hover, *:focus)
4.3. The Negation (Matches-None) Pseudo-class: :not()
button:not([DISABLED])
*:not(FOO)
html|*:not(:link):not(:visited)
4.4. The Specificity-adjustment Pseudo-class: :where()
a:not(:hover) {
text-decoration: none;
}
nav a {
/* Has no effect */
text-decoration: underline;
}
a:where(:not(:hover)) {
text-decoration: none;
}
nav a {
/* Works now! */
text-decoration: underline;
}
4.5. The Relational Pseudo-class: :has()
elements that contain an
child:
a:has(> img)
element
immediately followed by another
element:
dt:has(+ dt)
elements
that don’t contain any heading elements:
section:not(:has(h1, h2, h3, h4, h5, h6))
section:has(:not(h1, h2, h3, h4, h5, h6))
element
which contains anything that’s not a heading element.
5. Elemental selectors
5.1. Type (tag name) selector
5.2. Universal selector
*
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.
5.3. Namespaces in Elemental Selectors
|
U+007C).
(See, e.g., [XML-NAMES] for the use of namespaces in XML.)
It has the following meaning in each form:
ns|E
*|E
|E
E
@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 }
@namespace url("http://example.com/foo");
.special { ... }
5.4. The Defined Pseudo-class: :defined
custom-element { visibility: hidden }
custom-element:defined { visibility: visible }
6. Attribute selectors
6.1. Attribute presence and value selectors
att
attribute,
whatever the value of the attribute.
att
attribute
whose value is exactly "val".
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
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.
title
attribute,
whatever its value:h1[title]
class
attribute has
exactly the value "example":span[class="example"]
hello
attribute has exactly the value "Cleveland"
and whose goodbye
attribute has exactly the value
"Columbus":span[hello="Cleveland"][goodbye="Columbus"]
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/"] { ... }
hreflang
attribute is exactly "fr".a[hreflang=fr]
hreflang
attribute begins with
"en", including "en", "en-US", and "en-scouse":a[hreflang|="en"]
character
:DIALOGUE[character=romeo]
DIALOGUE[character=juliet]
6.2. Substring matching attribute selectors
att
attribute
whose value begins with the prefix "val".
If "val" is the empty string
then the selector does not represent anything.
att
attribute
whose value ends with the suffix "val".
If "val" is the empty string
then the selector does not represent anything.
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.
object[type^="image/"]
href
attribute whose value ends with ".html".a[href$=".html"]
title
attribute whose value contains the substring "hello"p[title*="hello"]
6.3. Case-sensitivity
i
before the closing bracket (]
).
When this flag is present,
UAs must match the attribute’s value ASCII case-insensitively (i.e. [a-z] and [A-Z] are considered equivalent).s
before the closing bracket (]
);
in this case the UA must match the value case-sensitively,
with “identical to” semantics [INFRA],
regardless of document language rules.i
and s
identifiers themselves
are ASCII case-insensitive.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; }
type="a"
attributes differently than type="A"
even though HTML defines the type
attribute
to be case-insensitive.
[type="a" s] { list-style: lower-alpha; }
[type="A" s] { list-style: upper-alpha; }
s
flags is only possible
in systems that preserve the original case.6.4. Attribute selectors and namespaces
|
). 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.@namespace foo "http://www.example.com";
[foo|att=val] { color: blue }
[*|att] { color: yellow }
[|att] { color: green }
[att] { color: green }
att
in the "http://www.example.com" namespace with the
value "val".att
regardless of the namespace of the attribute
(including no namespace).att
where the attribute is not
in a namespace.6.5. Default attribute values in DTDs
EXAMPLE
with an attribute radix
that has a default value of "decimal"
. The DTD fragment might be
EXAMPLE[radix=decimal] { /*... default property settings ...*/ }
EXAMPLE[radix=octal] { /*... other settings...*/ }
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...*/ }
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
class
attribute: in these languages
it is equivalent to the ~=
notation applied to the
local class
attribute
(i.e. [class~=identifier]
).class~="pastoral"
as follows:*.pastoral { color: green } /* all elements with class~=pastoral */
.pastoral { color: green } /* all elements with class~=pastoral */
class~="pastoral"
:H1.pastoral { color: green } /* H1 elements with class~=pastoral */
H1
instance below would not have
green text, while the second would:Not green
Very green
class
attribute has been assigned a list of whitespace-separated values that includes both pastoral
and marine
:p.pastoral.marine { color: green }
class="pastoral blue aqua
marine"
but does not match for class="pastoral
blue"
.6.7. ID selectors
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.#
)
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.)h1#chapter1
#chapter1
*#z98y
7. Linguistic Pseudo-classes
7.1. The Directionality Pseudo-class: :dir()
dir
attribute, the surrounding text, and other factors.
As another example, the its:dir
and dirRule
element
of the Internationalization Tag Set [ITS20] are able to define the directionality of an element in [XML10].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.)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()
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. [XML10]"*"
) does not match
elements whose language is not tagged (e.g. lang=""
),
but does match elements whose language is tagged as undetermined (lang=und
).
The matching is performed ASCII case-insensitively.
The language range does not need to be a valid language code to
perform this comparison.xml:lang
attributes. [XML10] See “FAQ: Two-letter or three-letter language codes.”html:lang(fr-be)
html:lang(de)
:lang(fr-be) > q
:lang(de) > q
8. Location Pseudo-classes
8.1. The Hyperlink Pseudo-class: :any-link
a
or area
elements with an href
attribute are hyperlinks,
and thus match :any-link
.
It matches an element if the element would match either :link or :visited,
and is equivalent to :is(:link, :visited).8.2. The Link History Pseudo-classes: :link and :visited
footnote
and already visited:
.footnote:visited
8.3. The Local Link Pseudo-class: :local-link
nav :local-link { text-decoration: none; }
pushState
API;
as well as by the more obvious actions of navigating to a different page
or following a redirect (which could be initiated by protocols such as HTTP,
markup instructions such as ,
or scripting instructions ).
UAs must ensure that :local-link,
as well as the :target and :target-within pseudo-classes below,
respond correctly to all such changes in state.
8.4. The Target Pseudo-class: :target
https://example.com/index.html#section2
,
for example,
points to the element with id="section2"
in the document at https://example.com/index.html
. p.note:target
p
element of class note
that is the target element of the referring
URL.:target { color : red }
:target::before { content : url(target.png) }
8.5. The Target Container Pseudo-class: :target-within
8.6. The Reference Element Pseudo-class: :scope
querySelector()
method in [DOM].
The :scope pseudo-class represents
this scoping root,
and may be either a true element
or a virtual one (such as a DocumentFragment
).DocumentFragment
df
,
then df
matches all the .foo elements that are "top-level" in the document fragment
(those that have the document fragment as their parentNode
).
df
will not match anything,
as the document fragment itself can’t be the subject of the selector.9. User Action Pseudo-classes
a:link /* unvisited links */
a:visited /* visited links */
a:hover /* user hovers */
a:active /* active links */
a:focus
a:focus:hover
9.1. The Pointer Hover Pseudo-class: :hover
:hover
when its label is hovered.9.2. The Activation Pseudo-class: :active
9.3. The Input Focus Pseudo-class: :focus
label
element;
the main objection seems to be implementation difficulty.
See CSSWG issue (CSS) and WHATWG issue (HTML).9.4. The Focus-Indicated Pseudo-class: :focus-visible
:root
input
element,
or any other element
that would triggers a virtual keyboard to be shown on focus
if a physical keyboard were not present), indicate focus.9.5. The Focus Container Pseudo-class: :focus-within
10. Time-dimensional Pseudo-classes
10.1. The Current-element Pseudo-class: :current
:current(p, li, dt, dd) {
background: yellow;
}
10.2. The Past-element Pseudo-class: :past
10.3. The Future-element Pseudo-class: :future
11. Resource State Pseudo-classes
11.1. Media Playback State: the :playing, :paused, and :seeking pseudo-classes
audio
and video
elements of HTML, see HTML § 4.8.11.9 Seeking.)11.2. Media Loading State: the :buffering and :stalled pseudo-classes
audio
and video
elements of HTML,
this amount of time is the media element stall timeout. [HTML] (Note that, like with the :buffering pseudo-class,
the element is still considered to be “playing” when it is “stalled”.
Whenever :stalled matches an element, :playing also matches the element.)11.3. Sound State: the :muted and :volume-locked pseudo-classes
audio
and video
elements of HTML, see muted. [HTML])12. Element Display State Pseudo-classes
12.1. Collapse State: the :open and :closed pseudo-class
details
, select
, and dialog
elements,
all of which can be toggled “open” to display more content
(or any content at all, in the case of dialog
).12.2. Modal (Exclusive Interaction) State: the :modal pseudo-class
dialog
element is :modal when opened with the showModal()
API.
Similarly, a :fullscreen element is also :modal when opened with the requestFullscreen()
API,
since this prevents interaction with the rest of the page. 12.3. Fullscreen Presentation State: the :fullscreen pseudo-class
12.4. Picture-in-Picture Presentation State: the :picture-in-picture pseudo-class
13. The Input Pseudo-classes
13.1. Input Control States
13.1.1. The :enabled and :disabled Pseudo-classes
13.1.2. The Mutability Pseudo-classes: :read-only and :read-write
element is :read-write,
as is any element with the
contenteditable
attribute set to the true state.13.1.3. The Placeholder-shown Pseudo-class: :placeholder-shown
placeholder
attribute in [HTML5].
The :placeholder-shown pseudo-class
matches an input element that is showing such placeholder text,
whether that text is given by an attribute or a real element,
or is otherwise implied by the UA.placeholder
attribute on the input
element
provide placeholder text,
as does the first option
element of a select
under certain conditions.
The :placeholder-shown class thus applies
whenever such placeholder text is shown. 13.1.4. The Automatic Input Pseudo-class: :autofill
13.1.5. The Default-option Pseudo-class: :default
(s) in a
,
and a few other elements.
13.2. Input Value States
13.2.1. The Selected-option Pseudo-class: :checked
elements match :checked.
selected
and checked
attributes in [HTML5]),
it applies to all media.input[type=checkbox]:not(:checked)
13.2.2. The Indeterminate-value Pseudo-class: :indeterminate
13.3. Input Value-checking
13.3.1. The Empty-Value Pseudo-class: :blank
textarea
element whose contents are empty,
or an input
field whose value is empty.
Note that the value under consideration here is the value
that would be submitted
(see A form control’s value in [HTML]),
which in HTML does not necessarily correspond to the value
of the element’s value
attribute. 13.3.2. The Validity Pseudo-classes: :valid and :invalid
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.
13.3.3. The Range Pseudo-classes: :in-range and :out-of-range
13.3.4. The Optionality Pseudo-classes: :required and :optional
13.3.5. The User-interaction Pseudo-classes: :user-valid and :user-invalid
14. Tree-Structural pseudo-classes
14.1. :root pseudo-class
14.2. :empty pseudo-class
p
elements
in the following HTML fragment:
14.3. Child-indexed Pseudo-classes
14.3.1. :nth-child() pseudo-class
n=0
the expression evaluates to 1.: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 */
:nth-child(-n+3 of li.important)
li.important:nth-child(-n+3)
tr {
background: white;
}
tr:nth-child(even) {
background: silver;
}
tr {
background: white;
}
tr:nth-child(even of :not([hidden])) {
background: silver;
}
14.3.2. :nth-last-child() pseudo-class
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 */
14.3.3. :first-child pseudo-class
div > p:first-child
p
inside the div
of the following fragment:p
in the following fragment: Note
* > a:first-child /* a is first child of any element */
a:first-child /* Same (assuming a is not the root element) */
14.3.4. :last-child pseudo-class
li
that
is the last child of an ordered list ol
.
ol > li:last-child
14.3.5. :only-child pseudo-class
14.4. Typed Child-indexed Pseudo-classes
14.4.1. :nth-of-type() pseudo-class
img
element matches this pseudo-class,
the S in question is html|img (assuming an appropriate html
namespace is declared).img:nth-of-type(2n+1) { float: right; }
img:nth-of-type(2n) { float: left; }
14.4.2. :nth-last-of-type() pseudo-class
img
element matches this pseudo-class,
the S in question is html|img (assuming an appropriate html
namespace is declared).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)
body > h2:not(:first-of-type):not(:last-of-type)
14.4.3. :first-of-type pseudo-class
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
dt
elements in the following example but not for the third one:
14.4.4. :last-of-type pseudo-class
td
of a table row tr
.
tr > td:last-of-type
14.4.5. :only-of-type pseudo-class
15. Combinators
15.1. Descendant combinator (
)B
that is an
arbitrary descendant of some ancestor element A
.h1 em
This headline
is very important
div * p
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]
15.2. Child combinator (
>
)body
:
body > p
div ol>li p
div
. Notice that the optional white
space around the ">" combinator has been left out.15.3. Next-sibling combinator (
+
)math + p
class="opener"
:h1.opener + h2
15.4. Subsequent-sibling combinator (
~
)h1 ~ pre
h1
. It
is a correct and valid, but partial, description of:Definition of the function a
function a(x) = 12x/13.5
16. Grid-Structural Selectors
16.1. Column combinator (
||
)col.selected || td {
background: gray;
color: white;
font-weight: bold;
}
A B C
D E
F G
16.2. :nth-col() pseudo-class
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.16.3. :nth-last-col() pseudo-class
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.17. Calculating a selector’s specificity
,
, or
.
,
, or .
* /* 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 :is(.bar, #baz)
/* a=1 b=1 c=0 */
style
attribute is described in CSS Style Attributes. [CSSSTYLEATTR]18. Grammar
18.1.
.
It is then parsed as a forgiving selector list to obtain its actual value.
19. API Hooks
querySelector
seem to make more sense being defined in the DOM specification than in Selectors.19.1. Parse A Selector
19.2. Parse A Relative Selector
19.3. Match a Selector Against an Element
19.4. Match a Selector Against a Pseudo-element
then return success.
19.5. Match a Selector Against a Tree
Appendix A: Guidance on Mapping Source Documents & Data to an Element Tree
Appendix B: Obsolete but Required
-webkit-
Parsing Quirks for Web Compat
What’s this quirk about?
input
-related pseudos some browsers expose),
not realizing that this hides the entire rule from other browsers.20. Changes
20.1. Changes since the 7 May 2022 Working Draft
20.2. Changes since the 21 November 2018 Working Draft
20.3. Changes since the 2 February 2018 Working Draft
s
to the attribute selector.
(Issue 2101)
20.4. Changes since the 2 May 2013 Working Draft
:local-link()
pseudo-class and reference combinator for lack of interest.
20.5. Changes since the 23 August 2012 Working Draft
20.6. Changes since the 29 September 2011 Working Draft
20.7. Changes Since Level 3
21. Acknowledgements
22. Privacy and Security Considerations
Conformance
Document conventions
class="example"
,
like this: class="note"
, like this: , like
this: UAs MUST provide an accessible alternative.
Conformance classes
Partial implementations
Implementations of Unstable and Proprietary Features
Non-experimental implementations
Index
Terms defined by this specification
Terms defined by reference
References
Normative References
Informative References
Issues Index
label
element;
the main objection seems to be implementation difficulty.
See CSSWG issue (CSS) and WHATWG issue (HTML). ↵querySelector
seem to make more sense being defined in the DOM specification than in Selectors. ↵