Selectors Level 4 This version: http://www.w3.org/TR/2011/WD-selectors4-20110929/ Editor's draft: http://dev.w3.org/csswg/selectors4/ Latest version of Selectors Level 4: http://www.w3.org/TR/selectors4/ Latest Selectors specification: http://www.w3.org/TR/selectors/ Previous version: - Editors: Previous Editors: Copyright © 2011 W3C ® ( MIT , ERCIM , Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.

Abstract

Selectors are patterns that match against elements in a tree, and as such form one of several technologies that can be used to select nodes in an XML document. Selectors have been optimized for use with HTML and XML, and are designed to be usable in performance-critical code. They are a core component of CSS (Cascading Style Sheets), which uses Selectors to bind style properties to elements in the document.

Selectors Level 4 describes the selectors that already exist in [SELECT], and further introduces new selectors for CSS and other languages that may need them.

Status of this Document

This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.

Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.

The (archived) public mailing list www-style@w3.org (see instructions) is preferred for discussion of this specification. When sending e-mail, please put the text “selectors4” in the subject, preferably like this: “[ selectors4 ] …summary of comment…”

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

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

This module is an early-stage Working Draft. If you are looking for a stable Selectors specification, use Selectors 3. Read the CSS Snapshot for an overview of the CSS development process. See the Selectors Overview for a summary of additions to level 3.

This is the first public Working Draft of this new specification.

Table of Contents

1. Introduction

This section is not normative.

Selectors define the following function for elements in a tree structure:

expression ∗ element → boolean

That is, given an element and a selector, this specification defines whether that element matches the selector.

These expressions can also be used, for instance, to select a set of elements, or a single element from a set of elements, by evaluating the expression across all the elements in a subtree. STTS (Simple Tree Transformation Sheets), a language for transforming XML trees, uses this mechanism. [STTS3]

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 for, 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:

The meaning of each selector is derived from the table above by prepending "matches" to the contents of each cell in the "Meaning" column.

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

3. Selector Syntax and Structure

3.1. Structure and Terminology

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

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

A compound selector is a chain of simple selectors that are not separated by a combinator. It always begins with a type selector or a (possibly implied) universal selector. No other type selector or universal selector is allowed in the sequence.

A simple selector is either a type selector, universal selector, attribute selector, class selector, ID selector, or pseudo-class.

Combinators are punctuation that represent a particular kind of relationship between the compound selectors on either side. Combinators in Selectors level 4 include: whitespace, "greater-than sign" (U+003E, > ), "plus sign" (U+002B, + ) and "tilde" (U+007E, ~ ). White space may appear between a combinator and the simple selectors around it.

An empty selector, containing no compound selector, is an invalid selector.

3.2. Determining the Subject of a Selector

The elements of a document tree that are represented by a selector are the subjects of the selector.

By default, the subjects of a selector are the elements represented by the last compound selector in the selector. Thus a selector consisting of a single compound selector represents any element satisfying its requirements. Prepending another compound selector and a combinator to a sequence imposes additional matching constraints, so the subjects of the selector are always a subset of the elements represented by the last compound selector.

The subject of the selector can be explicitly identified by prepending a dollar sign ($) to one of the compound selectors in a selector. Although the element structure that the selector represents is the same with or without the dollar sign, indicating the subject in this way can change which compound selector represents the subject in that structure.

For example, the following selector represents a list item LI unique child of an ordered list OL : OL > LI:only-child However the following one represents an ordered list OL having a unique child, that child being a LI : $OL > LI:only-child The structures represented by these two selectors are the same, but the subjects of the selectors are not.

3.3. Pseudo-classes

The pseudo-class concept is introduced to permit selection based on information that lies outside of the document tree or that cannot be expressed using the other simple selectors.

A pseudo-class always consists of a "colon" ( : ) followed by the name of the pseudo-class and, for functional pseudo-classes, by a value between parentheses. White space is optionally allowed between the parentheses and the argument, but not between the pseudo-class name and the parentheses.

Pseudo-classes are allowed in all compound selectors contained in a selector. Pseudo-classes are allowed anywhere in a compound selector after the leading type selector or (possibly omitted) universal selector. Pseudo-class names are case-insensitive. 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. Pseudo-classes may be dynamic, in the sense that an element can acquire or lose a pseudo-class while a user interacts with the document.

Dynamic pseudo-classes classify elements on characteristics other than their name, attributes, or content, in principle characteristics that cannot be deduced from the document tree.

Dynamic pseudo-classes do not appear in the document source or document tree.

3.4. Pseudo-elements

Pseudo-elements create abstractions about the document tree beyond those specified by the document language. For instance, document languages do not offer mechanisms to access the first letter or first line of an element's content. Pseudo-elements allow authors to refer to this otherwise inaccessible information. Pseudo-elements may also provide authors a way to refer to content that does not exist in the source document (e.g., the ::before and ::after pseudo-elements give access to generated content in CSS [CSS21]).

A pseudo-element is made of two colons ( :: ) followed by the name of the pseudo-element.

This :: notation was chosen in order to establish a discrimination between pseudo-classes (which subclass existing elements) and pseudo-elements (which are elements not represented in the document tree). However, for compatibility with existing style sheets, user agents must also accept the previous one-colon notation for pseudo-elements introduced in CSS levels 1 and 2 (namely, :first-line , :first-letter , :before and :after ). This compatibility notation is not allowed any other pseudo-elements.

Only one pseudo-element may appear per selector, and only if the subject of the selector is the last compound selector in the selector. If present the pseudo-element must appear after the compound selector that represents the subjects of the selector.

A future version of this specification may allow multiple pseudo-elements per selector.

Syntactically, a pseudo-element may be followed by any combination of the user action pseudo-classes. Whether these pseudo-classes can match on the pseudo-element depends on the pseudo-class and pseudo-element's definition: unless otherwise-specified, none of these pseudo-classes will match on the pseudo-element.

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

3.5. Characters and case sensitivity

All Selectors syntax is case-insensitive within the ASCII range (i.e. [a-z] and [A-Z] are equivalent), except for parts that are not under the control of Selectors. The case sensitivity of document language element names, attribute names, and attribute values in selectors depends on the document language. For example, in HTML, element names are case-insensitive, but in XML, they are case-sensitive. Case sensitivity of namespace prefixes is defined in [CSS3NAMESPACE].

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

Characters in Selectors can be escaped with a backslash according to the same escaping rules as CSS. [CSS21].

3.6. Namespaces

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]

3.7. Invalid Selectors and Error Handling

Invalidity is caused by a parsing error, e.g. an unrecognized token or a token which is not allowed at the current parsing point.

User agents must observe the rules for handling parsing errors:

a simple selector containing an undeclared namespace prefix is invalid

a selector containing an invalid simple selector, an invalid combinator or an invalid token is invalid.

a selector list containing an invalid selector is invalid.

An invalid selector represents nothing.

It's been requested that the last rule be dropped in favor of Media Queries-style error-handling.

4. Logical Combinations

4.1. Selector Lists

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

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

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

Invalid CSS example: h1 { font-family: sans-serif } h2..foo { font-family: sans-serif } h3 { font-family: sans-serif } is not equivalent to: h1, h2..foo, h3 { font-family: sans-serif } because the above selector ( h1, h2..foo, h3 ) is entirely invalid and the entire style rule is dropped. (When the selectors are not grouped, only the rule for h2..foo is dropped.)

4.2. The Matches-Any Pseudo-class: ‘ :matches() ’

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

In Selectors Level 4, only compound selectors are allowed within :matches() : combinators are not allowed. Additionally, :matches() may not be nested within itself or within :not() : :matches(:matches(...)) and :not(:matches(...)) are invalid.

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

Default namespace declarations do not affect the subject of any selector within a matches-any pseudo-class unless the argument is an explicit universal selector or a type selector.

For example, following selector matches any element that is being hovered or focused, regardless of its namespace. In particular, it is not limited to only matching elements in the default namespace that are being hovered or focused. *|*:matches(:hover, :focus) The following selector, however, represents only hovered or focused elements that are in the default namespace, because it uses an explicit universal selector within the :matches() notation: *|*:matches(*:hover, *:focus)

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

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

In Selectors Level 4, only compound selectors are allowed within :matches() : combinators are not allowed. Additionally, negations may not be nested within itself or within :matches() : :not(:not(...)) and :matches(:not(...)) are invalid.

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

For example, the following selector matches all button elements in an HTML document that are not disabled. button:not([DISABLED]) The following selector represents all but FOO elements. *:not(FOO) The following compound selector represents all HTML elements except links. html|*:not(:link):not(:visited)

Default namespace declarations do not affect the subject of any selector within a negation pseudo-class unless the argument is an explicit universal selector or a type selector. (See :matches() for examples.

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

5. Elemental selectors

5.1. Type selector

A type selector is the name of a document language element type written using the syntax of CSS qualified names [CSS3NAMESPACE]. A type selector represents an instance of the element type in the document tree.

Example: The following selector represents an h1 element in the document tree: h1

5.1.1. Type selectors and namespaces

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

The namespace component may be left empty (no prefix before the namespace separator) to indicate that the selector is only to represent elements with no namespace.

An asterisk may be used for the namespace prefix, indicating that the selector represents elements in any namespace (including elements with no namespace).

Element type selectors that have no namespace component (no namespace separator) represent elements without regard to the element's namespace (equivalent to " *| ") unless a default namespace has been declared for namespaced selectors (e.g. in CSS, in the style sheet). If a default namespace has been declared, such selectors will represent only elements in the default namespace.

A type selector containing a namespace prefix that has not been previously declared for namespaced selectors is an invalid selector.

In a namespace-aware client, the name part of element type selectors (the part after the namespace separator, if it is present) will only match against the local part of the element's qualified name.

In summary:

ns|E elements with name E in namespace ns *|E elements with name E in any namespace, including those without a namespace |E elements with name E without a namespace E if no default namespace has been declared for selectors, this is equivalent to *|E. Otherwise it is equivalent to ns|E where ns is the default namespace.

CSS examples: @namespace foo url(http://www.example.com); foo|h1 { color: blue } /* first rule */ foo|* { color: yellow } /* second rule */ |h1 { color: red } /* ...*/ *|h1 { color: green } h1 { color: green } The first rule (not counting the @namespace at-rule) will match only h1 elements in the "http://www.example.com" namespace. The second rule will match all elements in the "http://www.example.com" namespace. The third rule will match only h1 elements with no namespace. The fourth rule will match h1 elements in any namespace (including those without any namespace). The last rule is equivalent to the fourth rule because no default namespace has been defined.

5.2. Universal selector

The universal selector , written as a CSS qualified name [CSS3NAMESPACE] with an asterisk ( * U+002A) as the local name, represents the qualified name of any element type. It represents any single element in the document tree in any namespace (including those without a namespace) if no default namespace has been specified for selectors. If a default namespace has been specified, see Universal selector and Namespaces below.

If a universal selector represented by * (i.e. without a namespace prefix) is not the only component of a compound selector or is immediately followed by a pseudo-element, then the * may be omitted and the universal selector's presence implied.

Examples: *[hreflang|=en] and [hreflang|=en] are equivalent,

and are equivalent, *.warning and .warning are equivalent,

and are equivalent, *#myid and #myid are equivalent.

Note: it is recommended that the * not be omitted, because it decreases the potential confusion between, for example, div :first-child and div:first-child . Here, div *:first-child is more readable.

5.2.1. Universal selector and namespaces

The universal selector allows an optional namespace component. It is used as follows:

ns|* all elements in namespace ns *|* all elements |* all elements without a namespace * if no default namespace has been specified, this is equivalent to *|*. Otherwise it is equivalent to ns|* where ns is the default namespace.

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

6. Attribute selectors

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

6.1. Attribute presence and value selectors

CSS2 introduced four attribute selectors:

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

Attribute values must be CSS identifiers or strings. [CSS21]

Examples: The following attribute selector represents an h1 element that carries the title attribute, whatever its value: h1[title] In the following example, the selector represents a span element whose class attribute has exactly the value "example": span[class="example"] Multiple attribute selectors can be used to represent several attributes of an element, or several conditions on the same attribute. Here, the selector represents a span element whose hello attribute has exactly the value "Cleveland" and whose goodbye attribute has exactly the value "Columbus": span[hello="Cleveland"][goodbye="Columbus"] The following CSS rules illustrate the differences between "=" and "~=". The first selector would match, for example, an a element with the value "copyright copyleft copyeditor" on a rel attribute. The second selector would only match an a element with an href attribute having the exact value "http://www.w3.org/". a[rel~="copyright"] { ... } a[href="http://www.w3.org/"] { ... } The following selector represents an a element whose hreflang attribute is exactly "fr". a[hreflang=fr] The following selector represents an a element for which the value of the hreflang attribute begins with "en", including "en", "en-US", and "en-scouse": a[hreflang|="en"] The following selectors represent a DIALOGUE element whenever it has one of two different values for an attribute character : DIALOGUE[character=romeo] DIALOGUE[character=juliet]

6.2. Substring matching attribute selectors

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

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

Attribute values must be CSS identifiers or strings. [CSS21]

Examples: The following selector represents an HTML object , referencing an image: object[type^="image/"] The following selector represents an HTML anchor a with an href attribute whose value ends with ".html". a[href$=".html"] The following selector represents an HTML paragraph with a title attribute whose value contains the substring "hello" p[title*="hello"]

6.3. Case-sensitivity

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

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

6.4. Attribute selectors and namespaces

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

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

CSS examples: @namespace foo "http://www.example.com"; [foo|att=val] { color: blue } [*|att] { color: yellow } [|att] { color: green } [att] { color: green } The first rule will match only elements with the attribute att in the "http://www.example.com" namespace with the value "val". The second rule will match only elements with the attribute att regardless of the namespace of the attribute (including no namespace). The last two rules are equivalent and will match only elements with the attribute att where the attribute is not in a namespace.

6.5. Default attribute values in DTDs

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

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

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

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

Example: Consider an element EXAMPLE with an attribute radix that has a default value of "decimal" . The DTD fragment might be <!ATTLIST EXAMPLE radix (decimal,octal) "decimal"> If the style sheet contains the rules EXAMPLE[radix=decimal] { /*... default property settings ...*/ } EXAMPLE[radix=octal] { /*... other settings...*/ } the first rule might not match elements whose radix attribute is set by default, i.e. not set explicitly. To catch all cases, the attribute selector for the default value must be dropped: EXAMPLE { /*... default property settings ...*/ } EXAMPLE[radix=octal] { /*... other settings...*/ } Here, because the selector EXAMPLE[radix=octal] is more specific than the type selector alone, the style declarations in the second rule will override those in the first for elements that have a radix attribute value of "octal" . Care has to be taken that all property declarations that are to apply only to the default case are overridden in the non-default cases' style rules.

6.6. Class selectors

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

CSS examples: We can assign style information to all elements with class~="pastoral" as follows: *.pastoral { color: green } /* all elements with class~=pastoral */ or just .pastoral { color: green } /* all elements with class~=pastoral */ The following assigns style only to H1 elements with class~="pastoral" : H1.pastoral { color: green } /* H1 elements with class~=pastoral */ Given these rules, the first H1 instance below would not have green text, while the second would: <H1>Not green</H1> <H1 class="pastoral">Very green</H1> The following rule matches any P element whose class attribute has been assigned a list of whitespace-separated values that includes both pastoral and marine : p.pastoral.marine { color: green } This rule matches when class="pastoral blue aqua marine" but does not match for class="pastoral blue" .

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

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

6.7. ID selectors

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

An ID-typed attribute of a document language allows authors to assign an identifier to one element instance in the document tree. An ID selector contains a "number sign" (U+0023, # ) immediately followed by the ID value, which must be an CSS identifiers. An ID selector represents an element instance that has an identifier that matches the identifier in the ID selector.

Selectors does not specify how a UA knows the ID-typed attribute of an element. The UA may, e.g., read a document's DTD, have the information hard-coded or ask the user.

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

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

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

7. Location Pseudo-classes

7.1. The hyperlink pseudo-class: ‘ :any-link ’

The :any-link pseudo-class represents an element that acts as the source anchor of a hyperlink.

Any better name suggestions for this pseudo?

7.2. The link history pseudo-classes: ‘ :link ’ and ‘ :visited ’

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

The :link pseudo-class applies to links that have not yet been visited.

pseudo-class applies to links that have not yet been visited. The :visited pseudo-class applies once the link has been visited by the user.

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.

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

Note: 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 therefore treat all links as unvisited links, or implement other measures to preserve the user's privacy while rendering visited and unvisited links differently.

7.3. The local link pseudo-class ‘ :local-link ’

The :local-link pseudo-class allows authors to style links based on the users current location within a site and to differentiate site-internal versus site-external links. The :local-link pseudo-class represents an element that is the source anchor of a hyperlink whose target's absolute URI matches the element's own document URI. The fragment identifier of the document URI is stripped before matching against the link's URI; otherwise all portions of the URI are considered.

For example, the following rule prevents links targetting the current page from being underlined when they are part of the navigation list: nav :local-link { text-decoration: none; }

The pseudo-class can also accept a non-negative integer as its sole argument, which, if the document's URI is a URL, indicates the number of path levels to match: an argument of zero represents a link element whose target is in the same domain as the document's URI, ‘ 1 ’ represents a link element whose target has the same domain and first path segment, ‘ 2 ’ represents a link element whose target has the same domain, first, and second path segments, etc. Path segments are portions of the URL's path that are separated by forward slashes (/). If a segment is missing from the document's URL, a pseudo-class requiring that segment to match does not match anything. Similarly if the document's URI is not a URL, the pseudo-class does not match anything. The scheme, username, password, port, query string, and fragment portions of the URL are not considered when matching against :local-link( n ) .

Is there such a thing as IRL? Because we do want this to work for internationalized URLs, just not URNs.

So, given the links: <a href="http://www.example.com">Home</a> <a href="http://www.example.com/2011">2011</a> <a href="https://www.example.com/2011/03">March</a> <a href="http://www.example.com/2011/03/">March</a> <a href="http://example.com/2011/03">March</a> and the styles: a:local-link {...} a:local-link(0) {...} a:local-link(1) {...} a:local-link(2) {...} a:local-link(3) {...} If the document's URI is http://www.example.com/2011/03/ : Link 1 would receive Style 2 Link 2 would receive Styles 2 and 3 Link 3 would receive Styles 2, 3, and 4 Link 4 would receive Style 1 Link 5 would remain unstyled, and Style 5 would not be applied to anything.

The following example styles all site-external links with a dashed underline. :not(:local-link(0)) { text-decoration-style: dashed; }

7.4. The target pseudo-class ‘ :target ’

Some URIs refer to a location within a resource. This kind of URI ends with a "number sign" (#) followed by an anchor identifier (called the fragment identifier).

URIs with fragment identifiers link to a certain element within the document, known as the target element. For instance, here is a URI pointing to an anchor named section_2 in an HTML document:

http://example.com/html/top.html#section_2

A target element can be represented by the :target pseudo-class. If the document's URI has no fragment identifier, then the document has no target element.

Example: p.note:target This selector represents a p element of class note that is the target element of the referring URI.

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

7.5. The contextual reference element pseudo-class ‘ :scope ’

The :scope pseudo-class represents any element that is in the contextual reference element set. If no contextual reference element set is given, :scope is equivalent to :root .

The contextual reference element set is a (potentially empty) explicitly-specified set of elements, such as that specified by the querySelector() call in [SELECTORS-API2]. Specifications intending for this pseudo-class to match specific elements rather than the document's root element must define a contextual reference element set.

8. User Action Pseudo-classes

Interactive user agents sometimes change the rendering in response to user actions. Selectors provides three pseudo-classes for the selection of an element the user is acting on.

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

Examples: a:link /* unvisited links */ a:visited /* visited links */ a:hover /* user hovers */ a:active /* active links */ An example of combining dynamic pseudo-classes: a:focus a:focus:hover The last selector matches a elements that are in the pseudo-class :focus and in the pseudo-class :hover.

8.1. The pointer hover pseudo-class ‘ :hover ’

The :hover pseudo-class applies while the user designates an element with a pointing device, but does not necessarily activate it. For example, a visual user agent could apply this pseudo-class when the cursor (mouse pointer) hovers over a box generated by the element. User agents not that do not support interactive media do not have to support this pseudo-class. Some conforming user agents that support interactive media may not be able to support this pseudo-class (e.g., a pen device that does not detect hovering).

The parent of an element that is :hover is also in that state.

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

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

8.2. The activation pseudo-class ‘ :active ’

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

There may be document language or implementation specific limits on which elements can become :active .

Selectors doesn't define if the parent of an element that is ‘ :active ’ is also in that state.

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

8.3. The input focus pseudo-class ‘ :focus ’

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

There may be document language or implementation specific limits on which elements can acquire :focus .

9. Time-dimensional Pseudo-classes

These pseudo-classes classify elements with respect to the currently-displayed or active position in a time-dimensional canvas, such as during speech rendering of an HTML document.

9.1. The current-element pseudo-class ‘ :current ’

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

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

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

9.2. The past-element pseudo-class ‘ :past ’

The :past pseudo-class represents any element that is defined to occur entirely prior to a :current element. 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.

9.3. The future-element pseudo-class ‘ :future ’

The :future pseudo-class represents any element that is defined to occur entirely after a :current 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.

10. Linguistic Pseudo-classes

10.1. The directionality pseudo-class ‘ :dir() ’

The :dir() pseudo-class allows the author to write selectors that represent an element based on its directionality as determined by the document language. For example, in HTML [HTML401], the directionality of an element is determined by the dir attribute. The :dir() pseudo-class does not select based on stylistic states—for example, the CSS ‘ direction ’ property does not affect whether it matches.

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

The difference between :dir(C) and [dir=C] is that [dir=C] only performs a comparison against a given attribute on the element, while the :dir(C) pseudo-class uses the UAs knowledge of the document's semantics to perform the comparison. For example, in HTML, the directionality of an element inherits so that a child without a dir attribute will have the same directionality as its closest ancestor with a valid dir attribute. As another example, in HTML5, 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]

10.2. The language pseudo-class ‘ :lang ’

If the document language specifies how the human language of an element is determined, it is possible to write selectors that represent an element based on its language. For example, in HTML [HTML401], the language is determined by a combination of the lang attribute and possibly information from the meta elements or the protocol (such as HTTP headers). XML uses an attribute called xml:lang , and there may be other document language-specific methods for determining the language.

The pseudo-class :lang(C) represents an element that is in language C. Whether an element is represented by a :lang() selector is based solely on the element's language value (normalized to BCP 47 syntax if necessary) being equal to the identifier C, or beginning with the identifier C immediately followed by "-" (U+002D). The matching of C against the element's language value is performed case-insensitively within the ASCII range. The identifier C does not have to be a valid language name.

C must be a valid CSS identifier [CSS21] and must not be empty. (Otherwise, the selector is invalid.)

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

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

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

In this HTML example, only the BODY matches [lang|=fr] (because it has a LANG attribute) but both the BODY and the P match :lang(fr) (because both are in French). The P does not match the [lang|=fr] because it does not have a LANG attribute. <body lang=fr> <p>Je suis français.</p> </body>

11. The UI states pseudo-classes

11.1. The ‘ :enabled ’ and ‘ :disabled ’ pseudo-classes

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

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

What constitutes an enabled state, a disabled state, and a user interface element is language-dependent. In a typical document most elements will be neither :enabled nor :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.

11.2. The selected-option pseudo-class ‘ :checked ’

Radio and checkbox elements can be toggled by the user. Some menu items are "checked" when the user selects them. When such elements are toggled "on" the :checked pseudo-class applies. 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, it applies to all media. For example, the :checked pseudo-class initially applies to such elements that have the HTML4 selected and checked attributes as described in Section 17.2.1 of HTML4, but of course the user can toggle "off" such elements in which case the :checked pseudo-class would no longer apply.

An unchecked checkbox can be selected by using the negation pseudo-class: :not(:checked)

11.3. The indeterminate-value pseudo-class ‘ :indeterminate ’

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

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.

11.4. The default option pseudo-class ‘ :default ’

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

One example is the default submit button among a set of buttons. Another example is the default option from a popup menu. Multiple elements in a select-many group could have multiple :default elements, like a selection of pizza toppings for example.

11.5. The validity pseudo-classes ‘ :valid ’ and ‘ :invalid ’

An element is :valid or :invalid when its contents or value is, respectively, valid or invalid with respect to data validity semantics defined by the document language (e.g. [XFORMS10] or [HTML5]). An element which lacks data validity semantics is neither :valid nor :invalid . This is different from an element which otherwise has no constraints. Such an element would always be :valid . For example, a text input field with no constraints would always be :valid .

11.6. The range pseudo-classes ‘ :in-range ’ and ‘ :out-of-range ’

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

11.7. The optionality pseudo-classes ‘ :required ’ and ‘ :optional ’

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

11.8. The mutability pseudo-classes ‘ :read-only ’ and ‘ :read-write ’

An element whose contents are not user-alterable is :read-only . However, elements whose contents are user-alterable (such as text input fields) are considered to be in a :read-write state. In typical documents, most elements are :read-only . However it may be possible, depending on the document language, for any element to become :read-write . For example, in HTML5 any element with the contenteditable attribute set to the true state is considered user-alterable. [HTML5]

12. Tree-Structural pseudo-classes

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

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

12.1. ‘ :root ’ pseudo-class

The :root pseudo-class represents an element that is the root of the document. In HTML 4, this is always the HTML element.

12.2. ‘ :nth-child() ’ pseudo-class

The :nth-child( a n + b ) pseudo-class notation represents an element that has a n + b -1 siblings before it in the document tree, for any positive integer or zero value of n , and has a parent element. For values of a and b greater than zero, this effectively divides the element's children into groups of a elements (the last group taking the remainder), and selecting the b th element of each group. For example, this allows the selectors to address every other row in a table, and could be used to alternate the color of paragraph text in a cycle of four. The a and b values must be integers (positive, negative, or zero). The index of the first child of an element is 1.

In addition to this, :nth-child() can take ‘ odd ’ and ‘ even ’ as arguments instead. ‘ odd ’ has the same signification as 2n+1 , and ‘ even ’ has the same signification as 2n .

The argument to :nth-child() must match the grammar below, where INTEGER matches the token [0-9]+ and the rest of the tokenization is given by the Lexical scanner in section 10.2:

nth : S* [ ['-'|'+']? INTEGER? {N} [ S* ['-'|'+'] S* INTEGER ]? | ['-'|'+']? INTEGER | {O}{D}{D} | {E}{V}{E}{N} ] S* ;

Examples: tr:nth-child(2n+1) /* represents every odd row of an HTML table */ tr:nth-child(odd) /* same */ tr:nth-child(2n+0) /* represents every even row of an HTML table */ tr:nth-child(even) /* same */ /* Alternate paragraph colours in CSS */ p:nth-child(4n+1) { color: navy; } p:nth-child(4n+2) { color: green; } p:nth-child(4n+3) { color: maroon; } p:nth-child(4n+4) { color: purple; }

When the value b is preceded by a negative sign, the "+" character in the expression must be removed (it is effectively replaced by the "-" character indicating the negative value of b ).

Examples: :nth-child(10n-1) /* represents the 9th, 19th, 29th, etc, element */ :nth-child(10n+9) /* Same */ :nth-child(10n+-1) /* Syntactically invalid, and would be ignored */

When a =0, the a n part need not be included (unless the b part is already omitted). When a n is not included and b is non-negative, the + sign before b (when allowed) may also be omitted. In this case the syntax simplifies to :nth-child( b ) .

Examples: foo:nth-child(0n+5) /* represents an element foo that is the 5th child of its parent element */ foo:nth-child(5) /* same */

When a =1, or a =-1, the 1 may be omitted from the rule.

Examples: The following selectors are therefore equivalent: bar:nth-child(1n+0) /* represents all bar elements, specificity (0,1,1) */ bar:nth-child(n+0) /* same */ bar:nth-child(n) /* same */ bar /* same but lower specificity (0,0,1) */

If b =0, then every a th element is picked. In such a case, the + b (or - b ) part may be omitted unless the a part is already omitted.

Examples: tr:nth-child(2n+0) /* represents every even row of an HTML table */ tr:nth-child(2n) /* same */

Whitespace is permitted after the "(", before the ")", and on either side of the "+" or "-" that separates the a n and b parts when both are present.

Valid Examples with white space: :nth-child( 3n + 1 ) :nth-child( +3n - 2 ) :nth-child( -n+ 6) :nth-child( +6 ) Invalid Examples with white space: :nth-child(3 n) :nth-child(+ 2n) :nth-child(+ 2)

If both a and b are equal to zero, the pseudo-class represents no element in the document tree.

The value a can be negative, but only the positive values of a n + b , for n ≥0, may represent an element in the document tree.

Example: html|tr:nth-child(-n+6) /* represents the 6 first rows of XHTML tables */

12.3. ‘ :nth-last-child() ’ pseudo-class

The :nth-last-child( a n+ b ) pseudo-class notation represents an element that has a n + b -1 siblings after it in the document tree, for any positive integer or zero value of n , and has a parent element. See :nth-child() pseudo-class for the syntax of its argument. It also accepts the ‘ even ’ and ‘ odd ’ values as arguments.

Examples: tr:nth-last-child(-n+2) /* represents the two last rows of an HTML table */ foo:nth-last-child(odd) /* represents all odd foo elements in their parent element, counting from the last one */

12.4. ‘ :nth-of-type() ’ pseudo-class

The :nth-of-type( a n+ b ) pseudo-class notation represents an element that has a n + b -1 siblings with the same expanded element name before it in the document tree, for any zero or positive integer value of n , and has a parent element. See :nth-child() pseudo-class for the syntax of its argument. It also accepts the ‘ even ’ and ‘ odd ’ values.

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

12.5. ‘ :nth-last-of-type() ’ pseudo-class

The :nth-last-of-type( a n+ b ) pseudo-class notation represents an element that has a n + b -1 siblings with the same expanded element name after it in the document tree, for any zero or positive integer value of n , and has a parent element. See :nth-child() pseudo-class for the syntax of its argument. It also accepts the ‘ even ’ and ‘ odd ’ values.

Example: To represent all h2 children of an XHTML body except the first and last, one could use the following selector: body > h2:nth-of-type(n+2):nth-last-of-type(n+2) In this case, one could also use :not() , although the selector ends up being just as long: body > h2:not(:first-of-type):not(:last-of-type)

12.6. ‘ :nth-match() ’ pseudo-class

:nth-match( a n+ b of selector-list ) pseudo-class notation represents an element that has a parent and has a n + b -1 siblings that match the given selector-list before it in the document tree, for any zero or positive integer value of n .

See :nth-child() pseudo-class for the syntax of its a n+ b argument, which can also be replaced with the ‘ even ’ and ‘ odd ’ keywords.

12.7. ‘ :nth-last-match() ’ pseudo-class

:nth-last-match( a n+ b of selector-list ) pseudo-class notation represents an element that has a parent and has a n + b -1 siblings that match the given selector-list after it in the document tree, for any zero or positive integer value of n .

See :nth-child() pseudo-class for the syntax of its a n+ b argument, which can also be replaced with the ‘ even ’ and ‘ odd ’ keywords.

12.8. ‘ :first-child ’ pseudo-class

Same as :nth-child(1) . The :first-child pseudo-class represents an element that is the first child of some other element.

Examples: The following selector represents a p element that is the first child of a div element: div > p:first-child This selector can represent the p inside the div of the following fragment: <p> The last P before the note.</p> <div class="note"> <p> The first P inside the note.</p> </div> but cannot represent the second p in the following fragment: <p> The last P before the note.</p> <div class="note"> <h2> Note </h2> <p> The first P inside the note.</p> </div> but cannot represent the secondin the following fragment: The following two selectors are usually equivalent: * > a:first-child /* a is first child of any element */ a:first-child /* Same (assuming a is not the root element) */

12.9. ‘ :last-child ’ pseudo-class

Same as :nth-last-child(1) . The :last-child pseudo-class represents an element that is the last child of some other element.

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

12.10. ‘ :first-of-type ’ pseudo-class

Same as :nth-of-type(1) . The :first-of-type pseudo-class represents an element that is the first sibling of its type in the list of children of its parent element.

Example: The following selector represents a definition title dt inside a definition list dl , this dt being the first of its type in the list of children of its parent element. dl dt:first-of-type It is a valid description for the first two dt elements in the following example but not for the third one: <dl> <dt>gigogne</dt> <dd> <dl> <dt>fusée</dt> <dd>multistage rocket</dd> <dt>table</dt> <dd>nest of tables</dd> </dl> </dd> </dl>

12.11. ‘ :last-of-type ’ pseudo-class

Same as :nth-last-of-type(1) . The :last-of-type pseudo-class represents an element that is the last sibling of its type in the list of children of its parent element.

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

12.12. ‘ :only-child ’ pseudo-class

Represents an element that has a parent element and whose parent element has no other element children. Same as :first-child:last-child or :nth-child(1):nth-last-child(1) , but with a lower specificity.

12.13. ‘ :only-of-type ’ pseudo-class

Represents an element that has a parent element and whose parent element has no other element children with the same expanded element name. Same as :first-of-type:last-of-type or :nth-of-type(1):nth-last-of-type(1) , but with a lower specificity.

12.14. ‘ :empty ’ pseudo-class

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

Examples: p:empty is a valid representation of the following fragment: <p></p> foo:empty is not a valid representation for the following fragments: <foo>bar</foo> <foo><bar>bla</bar></foo> <foo>this is not <bar>:empty</bar></foo>

13. Grid-Structural Selectors

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

13.1. ‘ :column() ’ pseudo-class

The :column( selector-list ) pseudo-class notation represents a cell element belonging to a column that is represented by the element selected by its argument. Column membership is determined based on the semantics of the document language only: whether and how the elements are presented is not considered. If a cell element belongs to more than one column, it is represented by a selector indicating any of those columns.

The following example makes cells C, E, and G yellow. :column(col.selected) { background: yellow; } <table> <col span="2"> <col class="selected"> <tr><td>A <td>B <td>C <tr><td span="2">D <td>E <tr><td>F <td span="2">G </table>

13.2. ‘ :nth-column() ’ pseudo-class

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

See :nth-child() pseudo-class for the syntax of its argument. It also accepts the ‘ even ’ and ‘ odd ’ values as arguments.

13.3. ‘ :nth-last-column() ’ pseudo-class

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

See :nth-child() pseudo-class for the syntax of its argument. It also accepts the ‘ even ’ and ‘ odd ’ values as arguments.

14. Combinators

14.1. Descendant combinator

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"). Descendant combinators express such a relationship. A descendant combinator is whitespace that separates two compound selectors. A selector of the form " A B " represents an element B that is an arbitrary descendant of some ancestor element A .

Examples: For example, consider the following selector: h1 em It represents an em element being the descendant of an h1 element. It is a correct and valid, but partial, description of the following fragment: <h1>This <span class="myclass">headline is <em>very</em> important</span></h1> The following selector: div * p represents a p element that is a grandchild or later descendant of a div element. Note the whitespace on either side of the "*" is not part of the universal selector; the whitespace is a combinator indicating that the div must be the ancestor of some element, and that that element must be an ancestor of the p . The following selector, which combines descendant combinators and attribute selectors, represents an element that (1) has the href attribute set and (2) is inside a p that is itself inside a div : div p *[href]

14.2. Child combinators

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

Examples: The following selector represents a p element that is child of body : body > p The following example combines descendant combinators and child combinators. div ol>li p It represents a p element that is a descendant of an li element; the li element must be the child of an ol element; the ol element must be a descendant of a div . Notice that the optional white space around the ">" combinator has been left out.

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

14.3. Adjacent sibling combinator

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

Examples: The following selector represents a p element immediately following a math element: math + p The following selector is conceptually similar to the one in the previous example, except that it adds an attribute selector — it adds a constraint to the h1 element, that it must have class="opener" : h1.opener + h2

14.4. General sibling combinator

The general sibling combinator is made of the "tilde" (U+007E, ~ ) character 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.

Example: h1 ~ pre represents a pre element following an h1 . It is a correct and valid, but partial, description of: <h1>Definition of the function a</h1> <p>Function a(x) has to be applied to all figures in the table.</p> <pre>function a(x) = 12x/13.5</pre>

14.5. Reference combinators

The IDREF combinator consists of two slashes with an indetervening CSS qualified name, and separates two compound selectors, e.g. A /attr/ B . The elements represented by the two compound seletors are related in that an element represented by the first compound selector has an ID-reference to the element represented by the second compound selector. The ID reference can be given as either an IDREF or a fragment URL: the reference is valid as long as the value of the attribute named in the combinator consists of either the ID alone or a hash mark (#) followed by the ID. Attribute matching for reference combinators follow the same rules as for attribute selectors.

The following example highlights an <input> element when its <label> is focused or hovered-over: label:matches(:hover, :focus) /for/ input, /* association by "for" attribute */ label:matches(:hover, :focus):not([for]) input { /* association by containment */ box-shadow: yellow 0 0 10px; }

This could also be implemented as a functional pseudo-class.

15. Calculating a selector's specificity

A selector's specificity is calculated as follows:

count the number of ID selectors in the selector (= a)

count the number of class selectors, attributes selectors, and pseudo-classes in the selector (= b)

count the number of type selectors and pseudo-elements in the selector (= c)

ignore the universal selector

The specificity of a negation or matches pseudo-class is the specificity of its most specific argument. The pseudo-class itself does not count as pseudo-class.

It would probably be better to have match-sensitive specificity, if possible. See dbaron's message.

Concatenating the three numbers a-b-c (in a number system with a large base) gives the specificity.

Examples: * /* a=0 b=0 c=0 -> specificity = 0 */ LI /* a=0 b=0 c=1 -> specificity = 1 */ UL LI /* a=0 b=0 c=2 -> specificity = 2 */ UL OL+LI /* a=0 b=0 c=3 -> specificity = 3 */ H1 + *[REL=up] /* a=0 b=1 c=1 -> specificity = 11 */ UL OL LI.red /* a=0 b=1 c=3 -> specificity = 13 */ LI.red.level /* a=0 b=2 c=1 -> specificity = 21 */ #x34y /* a=1 b=0 c=0 -> specificity = 100 */ #s12:not(FOO) /* a=1 b=0 c=1 -> specificity = 101 */

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

Note: the specificity of the styles specified in an HTML style attribute is described in CSS 2.1. [CSS21].

16. Formal Syntax

This section needs to be updated.

16.1. Grammar

The grammar below defines the syntax of Selectors. It is globally LL(1) and can be locally LL(2) (but note that most UAs should not use it directly, since it doesn't express the parsing conventions). The format of the productions is optimized for human consumption and some shorthand notations beyond Yacc (see [YACC]) are used:

* : 0 or more

: 0 or more + : 1 or more

: 1 or more ? : 0 or 1

: 0 or 1 | : separates alternatives

: separates alternatives [ ]: grouping

The productions are:

selectors_group : selector [ COMMA S* selector ]* ; selector : compound_selector [ combinator simple_selector_sequence ]* ; combinator /* combinators can be surrounded by whitespace */ : PLUS S* | GREATER S* | TILDE S* | S+ ; simple_selector_sequence : [ type_selector | universal ] [ HASH | class | attrib | pseudo | negation ]* | [ HASH | class | attrib | pseudo | negation ]+ ; type_selector : [ namespace_prefix ]? element_name ; namespace_prefix : [ IDENT | '*' ]? '|' ; element_name : IDENT ; universal : [ namespace_prefix ]? '*' ; class : '.' IDENT ; attrib : '[' S* [ namespace_prefix ]? IDENT S* [ [ PREFIXMATCH | SUFFIXMATCH | SUBSTRINGMATCH | '=' | INCLUDES | DASHMATCH ] S* [ IDENT | STRING ] S* ]? ']' ; pseudo /* '::' starts a pseudo-element, ':' a pseudo-class */ /* Exceptions: :first-line, :first-letter, :before and :after. */ /* Note that pseudo-elements are restricted to one per selector and */ /* occur only in the last compound_selector. */ : ':' ':'? [ IDENT | functional_pseudo ] ; functional_pseudo : FUNCTION S* expression ')' ; expression /* In CSS3, the expressions are identifiers, strings, */ /* or of the form "an+b" */ : [ [ PLUS | '-' | DIMENSION | NUMBER | STRING | IDENT ] S* ]+ ; negation : NOT S* negation_arg S* ')' ; negation_arg : type_selector | universal | HASH | class | attrib | pseudo ;

16.2. Lexical scanner

The following is the tokenizer, written in Flex (see [FLEX]) notation. The tokenizer is case-insensitive.

The two occurrences of "\377" represent the highest character number that current versions of Flex can deal with (decimal 255). They should be read as "\4177777" (decimal 1114111), which is the highest possible code point in Unicode/ISO-10646. [UNICODE]

%option case-insensitive ident [-]?{nmstart}{nmchar}* name {nmchar}+ nmstart [_a-z]|{nonascii}|{escape} nonascii [^\0-\177] unicode \\[0-9a-f]{1,6}(\r

|[

\r\t\f])? escape {unicode}|\\[^

\r\f0-9a-f] nmchar [_a-z0-9-]|{nonascii}|{escape} num [0-9]+|[0-9]*\.[0-9]+ string {string1}|{string2} string1 \"([^

\r\f\\"]|\\{nl}|{nonascii}|{escape})*\" string2 \'([^

\r\f\\']|\\{nl}|{nonascii}|{escape})*\' invalid {invalid1}|{invalid2} invalid1 \"([^

\r\f\\"]|\\{nl}|{nonascii}|{escape})* invalid2 \'([^

\r\f\\']|\\{nl}|{nonascii}|{escape})* nl

|\r

|\r|\f w [ \t\r

\f]* D d|\\0{0,4}(44|64)(\r

|[ \t\r

\f])? E e|\\0{0,4}(45|65)(\r

|[ \t\r

\f])? N n|\\0{0,4}(4e|6e)(\r

|[ \t\r

\f])?|\

O o|\\0{0,4}(4f|6f)(\r

|[ \t\r

\f])?|\\o T t|\\0{0,4}(54|74)(\r

|[ \t\r

\f])?|\\t V v|\\0{0,4}(58|78)(\r

|[ \t\r

\f])?|\\v %% [ \t\r

\f]+ return S; "~=" return INCLUDES; "|=" return DASHMATCH; "^=" return PREFIXMATCH; "$=" return SUFFIXMATCH; "*=" return SUBSTRINGMATCH; {ident} return IDENT; {string} return STRING; {ident}"(" return FUNCTION; {num} return NUMBER; "#"{name} return HASH; {w}"+" return PLUS; {w}">" return GREATER; {w}"," return COMMA; {w}"~" return TILDE; ":"{N}{O}{T}"(" return NOT; @{ident} return ATKEYWORD; {invalid} return INVALID; {num}% return PERCENTAGE; {num}{ident} return DIMENSION; "<!--" return CDO; "-->" return CDC; \/\*[^*]*\*+([^/*][^*]*\*+)*\/ /* ignore comments */ . return *yytext;

17. Profiles

Each specification using Selectors must define the subset of Selectors it allows and excludes, and describe the local meaning of all the components of that subset.

17.1. CSS Profiles

This section is non-normative.

In CSS, selectors express pattern matching rules that determine which style rules apply to elements in the document tree.

The following selector (CSS level 2) will match all anchors a with attribute name set inside a section 1 header h1 :

h1 a[name]

All CSS declarations attached to such a selector are applied to elements matching it.

CSS Level 1 Selectors Profile Specification CSS level 1 Accepts type selectors

class selectors

ID selectors

:link, :visited and :active pseudo-classes

descendant combinator

::first-line and ::first-letter pseudo-elements Excludes namespace prefixes Extra constraints only one class selector allowed per compound selector, pseudo-elements only accept one-colon syntax

CSS Level 2 Selectors Profile Specification CSS level 2 Accepts type selectors

universal selector

attribute presence and values selectors

class selectors

ID selectors

:link, :visited, :active, :hover, :focus, :lang() and :first-child pseudo-classes

descendant combinator

child combinator

adjacent sibling combinator

::first-line and ::first-letter pseudo-elements

::before and ::after pseudo-elements Excludes namespaces, case-insensitive attribute selectors Extra constraints pseudo-elements only accept one-colon syntax

17.2. STTS Profiles

This section is non-normative.

Selectors can be used in STTS 3 in two different manners:

a selection mechanism equivalent to CSS selection mechanism: declarations attached to a given selector are applied to elements matching that selector, fragment descriptions that appear on the right side of declarations.

STTS3 Selectors Profile Specification STTS 3 Accepts type selectors

universal selectors

attribute selectors

class selectors

ID selectors

level 3 structural pseudo-classes

all combinators except reference combinator

namespaces Excludes namespaces, case-insensitive attribute selectors Extra constraints some selectors and combinators are not allowed in fragment descriptions on the right side of STTS declarations.

18. Conformance

18.1. Document Conventions

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

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

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

This is an example of an informative example.

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

Note, this is an informative note.

18.2. Conformance Classes

Conformance to Selectors Level 4 is defined for three conformance classes:

selector instance A written selector. interpreter A UA that interprets the semantics of a selector. authoring tool A UA that writes a style sheet.

A selector instance is conformant to Selectors Level 4 if it is valid according to the selector syntax rules defined in this specification.

An interpreter is conformant to Selectors Level 4 if it parses interprets selectors according to the semantics defined in Selectors Level 4 (including following the error-handling rules). However, the inability of a user agent to implement part of this specification due to the limitations of a particular device (e.g., non interactive user agents will probably not implement dynamic pseudo-classes because they make no sense without interactivity) does not imply non-conformance.

An authoring tool is conformant to Selectors Level 4 if it writes syntactically correct selectors.

Any specification reusing Selectors must contain a Profile listing the subset of Selectors it accepts or excludes, and describing any constraints it adds to the current specification.

Specifications reusing Selectors must define how to handle invalid selectors. (In the case of CSS, the entire rule in which the selector is used is effectively dropped.)

18.3. Partial Implementations

So that authors can exploit the forward-compatible parsing rules to trigger fallback behavior, UAs must treat as invalid any selectors for which they have no usable level of support.

18.4. Experimental Implementations

To avoid clashes with future Selectors features, the Selectors specification reserves a prefixed syntax for proprietary extensions to Selectors. The CSS Working Group recommends that experimental implementations of features in Selectors Working Drafts also use vendor-prefixed pseudo-element or pseudo-class names. This avoids any incompatibilities with future changes in the draft. Once a specification reaches the Candidate Recommendation stage, implementors should implement the non-prefixed syntax for any feature they consider to be correctly implemented according to spec.

19. Acknowledgements

The CSS working group would like to thank everyone who contributed to the previous Selectors specifications over the years, as those specifications formed the basis for this one.

In particular, the working group would like to extend special thanks to the following for their specific contributions to Selectors Level 4: L. David Baron, Andrew Fedoniouk, Ian Hickson, Grey Hodge, Lachlan Hunt, Jason Cranford Teague

20. References

20.1. Normative References