W3C

CSS3 module: W3C selectors

W3C Working Draft 5 October 2000

This version:
http://www.w3.org/TR/2000/WD-css3-selectors-20001005
Latest version:
http://www.w3.org/TR/css3-selectors
Previous version:
http://www.w3.org/TR/2000/WD-css3-selectors-20000410
Editors:
Tantek Çelik (Microsoft Corporation)
Daniel Glazman
Peter Linss (formerly of Netscape Communications)
John Williams (Quark, Inc.)

Copyright ©2000 W3C® (MIT, INRIA, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.

Abstract

CSS (Cascading Style Sheets) is a language for describing the rendering of HTML and XML documents on screen, on paper, in speech, etc. To bind style properties to elements in the document, it uses selectors, which are patterns that match to elements. This draft describes the selectors that are proposed for CSS level 3. It includes and extends the selectors of CSS level 2.

Status of this document

This document is a draft of one of the "modules" for the upcoming CSS3 specification. It not only describes the selectors that already exist in CSS1 and CSS2, but also proposes new selectors for CSS3 as well as for other languages that may need them. The Working Group doesn't expect that all implementations of CSS3 will have to implement all types of selectors. Instead, there will probably be a small number of variants of CSS3, so-called "profiles". For example, it may be that only the profile for non-interactive user agents will include all of the proposed selectors.

This document is a working draft of the CSS & FP working group which is part of the style activity.

The working group would like to receive feedback: comments on this draft may be send to the editor, discussion takes place on the (archived) public mailing list www-style@w3.org (see instructions). W3C Members can also send comments directly to the CSS & FP working group.

This working draft may be updated, replaced or rendered obsolete by other W3C documents at any time. It is inappropriate to use W3C Working Drafts as reference material or to cite them as other than "work in progress". Its publication does not imply endorsement by the W3C membership or the CSS & FP Working Group (members only).

To find the latest version of this working draft, please follow the "Latest version" link above, or visit the list of W3C Technical Reports.

Table of contents

1. Context

Members of the CSS+FP Working Group proposed during the Clamart meeting to modularize the CSS specification.

This modularization, and the externalization of the general syntax, of CSS will reduce the size of the specification and allow new types of specifications to use selectors and/or CSS general syntax. For instance behaviours or tree transformations.

2. Selectors

A W3C selector represents a structure. This structure can be understood for instance as a condition (e.g. in a CSS rule) that determines which elements in the document tree are matched by this selector, or as a flat description of the HTML or XML fragment corresponding to that structure.

W3C selectors may range from simple element names to rich contextual representations.

The following table summarizes W3C selector syntax:

Pattern Meaning Described in section First defined in CSS level
* any element Universal selector 2
E an element of type E Type element selector 1
E[foo] an E element with the "foo" attribute set Attribute selectors 2
E[foo="bar"] an E element whose "foo" attribute value is exactly equal to "bar" Attribute selectors 2
E[foo~="bar"] an E element whose "foo" attribute value is a list of space-separated values, one of which is exactly equal to "bar" Attribute selectors 2
E[foo^="bar"] an E element whose "foo" attribute value begins exactly with the string "bar" Attribute selectors 3
E[foo$="bar"] an E element whose "foo" attribute value ends exactly with the string "bar" Attribute selectors 3
E[foo*="bar"] an E element whose "foo" atrribute value contains the substring "bar" Attribute selectors 3
E[lang|="en"] an E element whose "lang" attribute has a hyphen-separated list of values beginning (from the left) with "en" Attribute selectors 2
E:root an E element, root of the document Structural pseudo-classes 3
E:first-child an E element, first child of its parent Structural pseudo-classes 2
E:not-first-child an E element, not the first child of its parent Structural pseudo-classes 3
E:last-child an E element, last child of its parent Structural pseudo-classes 3
E:not-last-child an E element, not the last child of its parent Structural pseudo-classes 3
E:first-of-type an E element, first sibling of its type Structural pseudo-classes 3
E:not-first-of-type an E element, not the first sibling of its type Structural pseudo-classes 3
E:last-of-type an E element, last sibling of its type Structural pseudo-classes 3
E:not-last-of-type an E element, not the last sibling of its type Structural pseudo-classes 3
E:only-of-type an E element, only sibling of its type Structural pseudo-classes 3
E:not-only-of-type an E element, not the only sibling of its type Structural pseudo-classes 3
E:only-child an E element, only child of its parent Structural pseudo-classes 3
E:not-only-child an E element, not the only child of its parent Structural pseudo-classes 3
E:nth-child(n) an E element, the n-th child of its parent Structural pseudo-classes 3
E:nth-of-type(n) an E element, the n-th sibling of its type Structural pseudo-classes 3
E:empty an E element that has no children (including text nodes) Structural pseudo-classes 3
E:link
E:visited		 an E element being the source anchor of a hyperlink of which the target is not yet visited (:link) or already visited (:visited) The link pseudo-classes 1
E:active
E:hover
E:focus		 an E element during certain user actions The user action pseudo-classes 1 and 2
E:target an E element being the target of the refering URI containing a fragment identifier The target pseudo-class 3
E:lang(c) an element of type E in (human) language c (the document language specifies how language is determined) The :lang() pseudo-class  2
E:enabled
E:disabled 		 a user interface element E which is enabled or disabled The UI element states pseudo-classes 3
E:checked
E:indeterminate 		 a user interface element E which is checked or and indeterminated checked state (for instance a radio-button or checkbox) The UI element states pseudo-classes 3
E:subject an E element that is a subject of the selector the current simple selectors belong to The subject element pseudo-class 3
E:contains("foo") an E element containing substring "foo" in its textual contents Content pseudo-class 3
E::first-line the first formatted line of an E element The :first-line pseudo-element 1
E::first-letter the first formatted letter of an E element The :first-letter pseudo-element 1
E::selection the portion of an E element that is currently selected/highlighted by the user The UI element fragments pseudo-elements 3
E::menu the generated menu attached to an E element The UI element fragments pseudo-elements 3
E::before generated content before an E element The :before pseudo-element 2
E::after generated content after an E element The :after pseudo-element 2
E.warning HTML only. The same as E[class~="warning"]. Class selectors 1
E#myid an E element, its ID being equal to "myid". ID selectors 1
E F an F element descendant of an E element Descendant combinator 1
E > F an F element child of an element E Child combinator 2
E + F an F element immediately preceded by an element E Direct adjacent combinator 2
E ~ F an F element preceded by an element E Indirect adjacent combinator 3

Example: in CSS, the meaning of each selector is derivated from the table above prepending "matches" to the contents of each cell of the "Meaning" column.

3. Case sensitivity

The case-sensitivity of document language element names in selectors depends on the document language. For example, in HTML, element names are case-insensitive, but in XML they are case-sensitive.

The case-sensitivity of attribute names and attribute values in attribute selectors also depend on the document language.

4. Selector syntax

A selector is a chain of one or more sequences of simple selectors separated by combinators.

A sequence of simple selectors is a chain of simple selectors that are not separated by a combinator. It always begin with a type selector or a 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, ID selector, content selector, pseudo-class or pseudo-element.

Combinators are: whitespace, ">", "+" and "~". Whitespace may appear between a combinator and the simple selectors around it. Only the characters "space" (Unicode code 32), "tab" (9), "line feed" (10), "carriage return" (13), and "form feed" (12) can occur in whitespace. Other space-like characters, such as "em-space" (8195) and "ideographic space" (12288), are never part of white-space.

The subjects of the selector are the most important elements represented by the selector. By default, the subjects of a selector are the elements represented by the last sequence of simple selectors in the selector. The :subject pseudo-class can modify this default behavior.

Examples:

The following selector represents a list item LI unique child of an ordered list OL: 

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

5. Groups of selectors

When several selectors share the same declarations, they may be grouped into a comma-separated list.

CSS example(s):

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 selectors are valid selectors. If one (or more) of these selectors is invalid, the group made of the three selectors is itself invalid, invalidating the rule ; then the equivalence is false.

6. Simple selectors

6.1 Type selector

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

Example(s):

The following selector represents an H1 element in the document tree: 

H1

6.1.1 Type selectors and Namespaces

Type selectors allow an optional namespace component. A namespace prefix that has been previously declared (via a @namespace at-rule) may be prepended to the element name separated by the namespace separator "|". The namespace component may be left empty to indicate that the selector is only to represent elements with no declared namespace. Furthermore, an asterisk may be used for the namespace prefix, indicating that the selector is to represent elements in any namespace (including elements with no namespace). Element type selectors that have no namespace component (no namespace separator), are considered to represent elements without regard to the element's namespace (equivalent to "*|") unless a default namespace has been declared, in that case, the selector will represent only elements in the default namespace.

An alternative approach would be to define element type selectors that have no namespace component to match only elements that have no namespace (unless a default namespace has been declared in the CSS). This would make the selector "h1" equivalent to the selector "|h1" as opposed to "*|h1". The downside to this approach is that legacy style sheets (those written without any namespace constructs) will fail to match in all XML documents where namespaces are used throughout, i.e. all XHTML documents.

It should be noted that if a namespace prefix used in a selector has not been previously declared, then the selector must be considered invalid and the entire style rule will be ignored in accordance with the standard error handling rules.

It should further be noted that in a namespace aware client, element type selectors will only match against the local part of the element's qualified name. See below for notes about matching behaviors in down-level clients.

In summary :

ns|E
elements with name E in namespace ns
*|E
elements with name E in any namespace, including those without any declared namespace
|E
elements with name E without any declared namespace
E
if no default namespace has been specified, 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.foo.com);

foo|h1 { color: blue }

foo|* { color: yellow }

|h1 { color: red }

*|h1 { color: green }

h1 { color: green }

The first rule will match only h1 elements in the "http://www.foo.com" namespace.

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

The third rule will match only h1 elements without any declared namespace.

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

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

6.2 Universal selector

The universal selector, written "*", represents the qualified name of any element type. It represents then any single element in the document tree in any namespace (including those without any declared namespace).

If the universal selector is not the only component of a sequence of simple selectors, the * may be omitted. For example:

Warning : it is recommended that the *, representing the universal selector, not be omitted.

6.2.1 Universal selector and Namespaces

The universal selector allows an optional namespace component.

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

6.3 Attribute selectors

W3C selectors allows representation of attributes attached to an element.

6.3.1 Representation of attributes and attribute values

Four different attribute selectors are available:

[att]
Represents the att attribute, whatever the value of the attribute.
[att=val]
Represents the att attribute, its value being exactly "val".
[att~=val]
Represents the att attribute, its value being a space-separated list of words, one of which is exactly "val". If this selector is used, the words in the value must not contain spaces (since they are separated by spaces).
[att|=val]
Represents the att attribute, its value being a hyphen-separated list of words, beginning with "val". The match always starts at the beginning of the attribute value. This is primarily intended to allow language subcode matches (e.g., the LANG attribute in HTML) as described in RFC 1766 ([RFC1766]).

Attribute values must be identifiers or strings. The case-sensitivity of attribute names and values in selectors depends on the document language.

Example(s):

For example, the following attribute selector represents a H1 element that carries the TITLE attribute, whatever its value: 

H1[TITLE]
Example(s):

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 even several times the same attribute.

Example(s):

Here, the selector represents a SPAN element whose hello attribute has exactly the value "Cleveland" and whose goddbye attribute has exactly the value "Columbus": 

SPAN[hello="Cleveland"][goodbye="Columbus"]
Example(s):

The following selectors illustrate the differences between "=" and "~=". The first selector will represent, for example, the value "copyright copyleft copyeditor" for the rel attribute. The second selector will only represent a A with the href attribute having the exact value "http://www.w3.org/". 

A[rel~="copyright"]
A[href="http://www.w3.org/"]
Example(s):

The following selector represents an arbitrary element for which the value of the lang attribute is "fr" (i.e., the language is French). 

*[LANG=fr]
Example(s):

The following selector represent an arbitrary element for which the values of the lang attribute begins with "en", including "en", "en-US", and "en-cockney": 

*[LANG|="en"]
Example(s):

Similarly, the following selectors represents a DIALOGUE element having two different values for the same attribute character: 

DIALOGUE[character=romeo] 

DIALOGUE[character=juliet]

6.3.2 Substring matching attribute selectors

Three different attribute selectors are also available for pattern representation into the string value of an attribute :

[att^="val"]
Represents the att attribute, its string value beginning exactly with the prefix "val"
[att$="val"]
Represents the att attribute, its string value ending exactly with the suffix "val"
[att*="val"]
Represents the att attribute, its string value containing at least once the substring "val"

Attribute values must be identifiers or strings. The case-sensitivity of attribute names in selectors depends again on the document language.

Example(s) :

The following selector represents an HTML object, referencing an image :

OBJECT[TYPE^="image/"]

The following selector represents a XML foo1 element carrying the bar attribute ; the value of this attribute ends with "cpg".

foo1[bar$="cpg"]

The following selector represents a HTML paragraph, its title attribute containing the substring "hello"

P[TITLE*="hello"]

6.3.3 Attribute selectors and Namespaces

Attribute selectors allow an optional namespace component to the attribute name. A namespace prefix that has been previously declared (via a @namespace at-rule) may be prepended to the attribute name separated by the namespace separator "|". 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 declared 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.

CSS examples: 

@namespace foo "http://www.foo.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.foo.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 declared namespace).

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

6.3.4 Default attribute values in DTDs

Attribute selectors represent attribute values in the document tree. Default attribute values may be defined in a DTD or elsewhere. W3C selectors should be implemented so that they work even if the default values are not included in the document tree.

Example(s):

For example, consider an element EXAMPLE with an attribute "notation" that has a default value of "decimal". The DTD fragment might be 

<!ATTLIST EXAMPLE notation (decimal,octal) "decimal">
If the selectors represent an EXAMPLE element when the value of the attribute is explicitely set: 
EXAMPLE[notation=decimal]
EXAMPLE[notation=octal]
then to represent the case where this attribute is set by default, and not explicitly, the following selector might be used: 
EXAMPLE

6.4 Class selectors

Working with HTML, authors may use the dot (.) notation as an alternative to the ~= notation when representing the class attribute. Thus, for HTML, DIV.value and DIV[class~=value] have the same meaning. The attribute value must immediately follow the ".".

Example(s):

For example, we can represent an arbitrary element with class~="pastoral" as follows: 

*.pastoral
or just 
.pastoral
The following selector represents a H1 element with class~="pastoral": 
H1.pastoral
Example(s):

For example, the following selector represents a P element whose class attribute has been assigned a list of space-separated values that includes "pastoral" and "marine": 

P.pastoral.marine

It is fully identical to :

P.marine.pastoral

This selector represents for instance a P with class="pastoral blue aqua marine" or class="marine blue pastoral aqua" but does not with class="pastoral blue".

6.5 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 document, regardless of the type of the elements that carry them ; whatever the document language, an ID 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.

The ID attribute of a document language allows authors to assign an identifier to one element instance in the document tree. W3C ID selectors represent an element instance based on its identifier. An ID selector contains a "#" immediately followed by the ID value.

Example(s):

The following ID selector represent a H1 element whose ID attribute has the value "chapter1": 

H1#chapter1

The following ID selector represent any element whose ID attribute has the value "chapter1": 

#chapter1
The following selector represents any element that has the ID value "z98y". 
*#z98y
Note. In XML 1.0 [XML10], the information about which attribute contains an element's IDs is contained in a DTD. When parsing XML, UAs do not always read the DTD, and thus may not know what the ID of an element is. If a style sheet designer knows or suspects that this will be the case, he should use normal attribute selectors instead: [name=p371] instead of #p371. Of course, elements in XML 1.0 documents without a DTD do not have IDs at all.

6.6 Pseudo-classes

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 contains a colon (:) followed by the name of the pseudo-class and optionnaly by a value between parentheses.

Pseudo-classes are allowed in all sequences of simple selectors contained in a selector. Pseudo-classes are allowed anywhere in sequences of simple selectors, after the leading type selector or universal selector (eventually omitted). Pseudo-class names are case-insensitive. Some pseudo-classes are mutually exclusive, while others can be applied simultaneously to the same element.

6.6.1 Dynamic pseudo-classes

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 may be dynamic, in the sense that an element may acquire or lose a pseudo-class while a user interacts with the document.

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

The link pseudo-classes: :link and :visited

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

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

The two states are mutually exclusive.

Example(s):

The following selector represents links carrying class external and already visited : 

A.external:visited
The user action pseudo-classes :hover, :active, and :focus

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

Only elements whose 'user-input' property (see [UI]) has the value of "enabled" can become :active or acquire :focus.

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

Example(s): 
A:link    /* unvisited links */
A:visited /* visited links   */
A:hover   /* user hovers     */
A:active  /* active links    */

Example(s):

An example of combining dynamic pseudo-classes: 

A:focus
A:focus:hover

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

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

6.6.2 The target pseudo-class :target

Some URIs refer to a location within a resource. This kind of URI ends with "#" 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 a HTML document: 

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

A target element can be represented by the :target pseudo-class: 

P.bar:target

represents a P of class bar that is the target element of the refering URI.

Rules containing a :target pseudo-class have no effect in environments where the notion of a target element is meaningless.

CSS example of use of the :target pseudo-class : 
*:target { color : red }

*:target:before { content : url(target.png) }

6.6.3 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 [HTML40], the language is determined by a combination of the LANG attribute, the META element, and possibly by information from 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. Here is a C language code as specified in HTML 4.0 [HTML40] and RFC 1766 [RFC1766]. It is matched the same way as for the '|=' operator.

Example(s):

The two following selectors represent an HTML document that is in French or German. The two next selectors represent Q quotations in an arbitrary element in French or German. 

HTML:lang(fr)
HTML:lang(de)
:lang(fr) > Q
:lang(de) > Q

6.6.4 The UI element states pseudo-classes

The :enabled and :disabled pseudo-classes

The purpose of the :enabled pseudo-class is to allow authors to customize the look of user interface elements which are enabled - which the user can select/activate in some fashion (e.g. clicking on a button with a mouse). There is a need for such a pseudo-class because as of yet there is no way to programmatically specify the default appearance of say, an enabled INPUT element without also specifying what it would look like when it was disabled.

Similar to :enabled, :disabled allows the author to specify precisely how a disabled or inactive user interface element should look.

It should be noted that most elements will be neither enabled nor disabled. An element is enabled if the user can either activate it or transfer the focus to it. An element is disabled if it could be enabled, but the user cannot presently activate it or transfer focus to it.

The :checked pseudo-class

The :checked pseudo-class only applies to elements which are 'user-input: enabled' or 'user-input : disabled' (see [UI] for the 'user-input' property). 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. The :checked pseudo-class initially applies to such elements that have the HTML4 SELECTED attribute 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. While the :checked pseudo-class is dynamic in nature, and is altered by user action, since it can also be based on the presence of the semantic HTML4 SELECTED attribute, it applies to all media.

The :indeterminate pseudo-class

The :indeterminate pseudo-class only applies to elements which are 'user-input: enabled' or 'user-input: disabled' (see [UI] for the 'user-input' property). Radio and checkbox elements can be toggled by the user, but are sometimes in an indeterminate state, neither checked nor unchecked. This can be due to an element attribute, or DOM manipulation. The :indeterminate pseudo-class applies to such elements. While the :indeterminate pseudo-class is dynamic in nature, and is altered by user action, since it can also be based on the presence of an element attribute, it applies to all media.

6.6.5 Structural pseudo-classes

W3C selectors introduce 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.

Note that standalone PCDATA 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.

:root pseudo-class

The :root pseudo-class represents an element that is the root of the document. In HTML 4, this is the HTML element. In XML, it is whatever is appropriate for the dtd/scheme/namespace for that XML document.

:first-child pseudo-class

The :first-child pseudo-class represents an element that is the first child of some other element.

Example(s):

In the following example, the 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.
<DIV class="note">
   <P> The first P inside the note.
</DIV>
but cannot represent the second P in the following fragment: 
<P> The last P before the note.
<DIV class="note">
   <H2>Note</H2>
   <P> The first P inside the note.
</DIV>
The following two selectors are equivalent: 
* > A:first-child   /* A is first child of any element */
A:first-child       /* Same */
:not-first-child pseudo-class

The :not-first-child pseudo-class represents an element that is not the first child of some other element.

Example(s):

The following selector represents all TD cells of a table row TR but the first one. 

TR TD:not-first-child
:last-child pseudo-class

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
:not-last-child pseudo-class

The :not-last-child pseudo-class represents an element that is not the last child of some other element.

Example:

The following selector represents all children but last one of a DIV. 

DIV > *:not-last-child
:first-of-type pseudo-class

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 in the following example but not for the third one: 
<DL><DT>gigogne</DT>
        <DD><DL><DT>fus&eacute;e</DT>
                    <DD>multistage rocket</DD>
                <DT>table</DT>
                    <DD>nest of tables</DD>
            </DL></DD>
</DL>
:not-first-of-type pseudo-class

The :not-first-of-type pseudo-class represents an element that is not the first sibling of its type in the list of children of its parent element.

Example:

The following selector represents all paragraphs P but the first that are children of the body of a document. 

BODY > P:not-first-of-type
:last-of-type pseudo-class

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 > TD:last-of-type
:not-last-of-type pseudo-class

The :not-last-of-type pseudo-class represents an element that is not the last sibling of its type in the list of children of its parent element.

Example:

The following selector represents all paragraphs P but the last one that are children of a DIV. 

DIV > P:not-last-of-type
:only-of-type pseudo-class

The :only-of-type pseudo-class represents an element that is the only sibling of its type in the list of children of its parent element.

Example:

The following selector represents an ADDRESS element that is the only one of its type in the list of children of the body of the document. 

BODY > ADDRESS:only-of-type
:not-only-of-type pseudo-class

The :not-only-of-type pseudo-class represents an element that is not the only sibling of its type in the list of children of its parent element.

Example:

The following selector represents a table row TR that contains more than one data cell TD. 

TR:selected TD:not-only-of-type
:only-child pseudo-class

The :only-child pseudo-class represents an element that is the only child of its parent element.

Example:

The following selector represents an unordered list UL with only one child, this child being a list item LI. 

UL:selected > LI:only-child
The :only-child pseudo-class has the same meaning as the pseudo-classes :first-child and :last-child applied together.
:not-only-child pseudo-class

The :not-only-child pseudo-class represents an element that is not the only child of its parent element.

Example:

The following selector represents a DIV with a child paragraph P and other children. 

DIV:selected > P:not-only-child
:nth-of-type(n) pseudo-class

The :nth-of-type(n) pseudo-class notation represents an element that is the n-th element of its type in the list of children of its parent element.

:nth-of-type(1) and :first-of-type pseudo-classes have the same meaning.

Example:

The following selector represents the second table row TR of a table body TBODY. 

TBODY > TR:nth-of-type(2)
:not-nth-of-type(n) pseudo-class

The :nth-of-type(n) pseudo-class notation represents an element that is not the n-th element of its type in the list of children of its parent element.

:not-nth-of-type(1) and :not-first-of-type pseudo-classes have the same meaning.

:nth-child(n) pseudo-class

The :nth-child(n) pseudo-class notation represents an element that is the n-th child of its parent element.

:nth-child(1) and :first-child pseudo-classes have the same meaning.

Example:

The following selector represents the second child of a DIV, whatever its type. 

DIV > *:nth-child(2)
:not-nth-child(n) pseudo-class

The :nth-child(n) pseudo-class notation represents an element that is not the n-th child of its parent element.

:not-nth-child(1) and :not-first-child pseudo-classes have the same meaning.

6.6.6 Content pseudo-class

The :contains("foo") represents a substring of the textual contents of an element. The argument of this pseudo-class can be a string (surrounded by double quotes) or a keyword.

The textual contents of a given element is determined by the concatenation of all PCDATA contained in the element and sub-elements.

Example: 
P:contains("Markup")
is a correct and valid, but partial, description of: 
<P><STRONG>H</STRONG>yper<STRONG>t</STRONG>ext
   <STRONG>M</STRONG><EM>arkup</EM>
   <STRONG>L</STRONG>anguage</P>

Special characters can be inserted in the argument of a content pseudo-class using the escape mechanism for unicode characters and carriage returns.

Note : :contains() is a pseudo-class, not a pseudo-element. The following CSS rule applied to the HTML fragment above will not add a red background only to the word "Markup" but will add such a background to the whole paragraph.
P:contains("Markup") { background-color : red }

Editor's note : need to add here a strong warning about performance issues related to this pseudo.

6.6.7 :empty pseudo-class

The :empty pseudo-class represents an element that has no children at all, including text nodes.

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>

6.7 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 designers to refer to this otherwise inaccessible information. Pseudo-elements may also provide designers 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).

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

Warning : this :: notation is introduced by the current document in order to establish a discrimination between pseudo-classes and pseudo-elements. For compatibility reasons with existing stylesheets, user agents must also accept the one-colon previous notation. This compatibility is not required for the new pseudo-elements the current document introduces.

Pseudo-elements may only appear in the sequence of simple selectors that represents the subjects of the selector.

Pseudo-elements names are case-insensitive.

6.7.1 The ::first-line pseudo-element

The ::first-line pseudo-element describes the first formatted line of a paragraph.

The ::first-line pseudo-element is similar to an inline-level element, but with certain restrictions, depending on usage.

The ::first-line pseudo-element can only be attached to a block-level element.

6.7.2 The :first-letter pseudo-element

The ::first-letter pseudo-element describes the first formetted letter of a paragraph

The ::first-letter pseudo-element is similar to an inline-level element if its CSS 'float' property is 'none', but with certain restrictions, depending on usage.

The ::first-letter pseudo-element can be attached to all elements.

6.7.3 The UI element fragments pseudo-elements

The ::selection pseudo-element

The ::selection pseudo-element applies to the portion of a document that has been highlighted by the user. This also applies, for example, to selected text within an editable text field. Only elements that have a user-select other than 'none' can have a ::selection. This pseudo-element should not be confused with the :checked pseudo-class (which used to be named :selected) or the :subject pseudo-class in the Selectors Proposal.

Although the ::selection pseudo-element is dynamic in nature, and is altered by user action, it is reasonable to expect that when a UA rerenders to a static medium (such as a printed page) which was originally rendered to a dynamic medium (like screen), the UA may wish to transfer the current ::selection state to that other medium, and have all the appropriate formatting and rendering take effect as well. This is not required - UAs may omit the ::selection pseudo-element for static media.

The ::menu pseudo-element

Authors can specify the style and location of a generated menu with the ::menu pseudo-element. It is treated as a child of the element (and therefore inherits all styling by default - similar to ::before and ::after), and absolutely positioned at 0,0 with respect to the content top left corner of the element. It is made "visibility:visible" when the element itself is :active, and is "visibility:hidden" otherwise. It contains a copy of all the contents of the element itself.

6.7.4 The ::before and ::after pseudo-elements

The ::before and ::after pseudo-elements can be used to describe generated content before or after an element's content.

When the ::first-letter and ::first-line pseudo-elements are combined with ::before and ::after, they apply to the first letter or line of the element including the inserted text.

7. Combinators

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

Example(s):

For example, consider the following selector: 

H1 EM
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 "*".

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]

7.2 Child combinators

A child combinator describes a childhood relationship between two elements. A child combinator is made of the ">" character and separates two sequences of simple selectors.

Example(s):

The following selector represents a P element that is child of BODY: 

BODY > P

Example(s):

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; 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 whitespace 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.

7.3 Adjacent sibling combinators

There are two different adjacent sibling combinators: direct adjacent combinator and indirect adjacent combinator.

7.3.1 Direct adjacent combinators

Direct adjacent combinators are made of the "+" character that separates two sequences of simple selectors. The elements represented by the two sequences share the same parent in the document tree and the element represented by the first sequence immediately precedes the element represented by the second one.

Example(s):

Thus, the following selector represents a P element immediately following a MATH element: 

MATH + P
Example(s):

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

H1.opener + H2

7.3.2 Indirect adjacent combinator

Indirect adjacent combinators are made of the "~" character that separates two sequences of simple selectors. The elements represented by the two sequences share the same parent in the document tree and the element represented by the first sequence precedes (not necessarily immediately) the element represented by the second one.

Example(s): 
H1 ~ PRE
represents a PRE element following a H1. It is a correct and valid, but partial, description of: 
<H1>section title</H1>
<P>This paragraphe describes a piece of code</P>
<PRE>function a(x) = 1/X</PRE>

8. Calculating a selector's specificity

A selector's specificity is calculated as follows:

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

Example(s):

Some 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 */

9. The grammar of W3C selectors

9.1 Grammar

The grammar below defines the syntax of W3C selectors. It is globally LL(1) and can be locally LL(2) (but note that most UA's 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]) is used:

The productions are: 

simple_selector_sequence
  : [ [ namespace_prefix ]? element_name ]? [ HASH | class | attrib | pseudoclass |
                                              pseudoelement ]* S*
  ;

namespace_prefix
  : [ IDENT | '*' ]? '|'
  ;

element_name
  : IDENT | '*'
  ;
class
  : '.' IDENT
  ;

attrib
  : '[' S* [ namespace_prefix ]? IDENT S* [ [
               [ [ PREFIXMATCH | SUFFIXMATCH | SUBSTRINGMATCH ] S* STRING ]
             | [ [ '=' | INCLUDES | DASHMATCH ] S* [IDENT | STRING] ]
           ] S* ]? ']'
  ;

pseudoclass
  : ':' [ IDENT | FUNCTION S* [ IDENT | STRING | NUMBER ] S* ')' ]
  ;

pseudoelement
  : '::' IDENT
  ;

combinator
  : '+' S* | '>' S* | '~' S* | /* empty */
  ;

selector
  : simple_selector_sequence [ combinator simple_selector_sequence ]*
  ;

selectors_group
  : selector [ ',' S* selector ]*
  ;

9.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. 

%option case-insensitive

h                       [0-9a-f]
nonascii                [\200-\377]
unicode                 \\{h}{1,6}[ \t\r\n\f]?
escape                  {unicode}|\\[ -~\200-\377]
nmstart                 [a-z]|{nonascii}|{escape}
nmchar                  [a-z0-9-]|{nonascii}|{escape}
string1                 \"([\t !#$%&(-~]|\\{nl}|\'|{nonascii}|{escape})*\"
string2                 \'([\t !#$%&(-~]|\\{nl}|\"|{nonascii}|{escape})*\'

ident                   {nmstart}{nmchar}*
name                    {nmchar}+
num                     [0-9]+|[0-9]*"."[0-9]+
string                  {string1}|{string2}
nl                      \n|\r\n|\r|\f
%%

[ \t\r\n\f]+    {return S;}

\/\*[^*]*\*+([^/][^*]*\*+)*\/   /* ignore comments */

"~="                    {return INCLUDES;}
"|="                    {return DASHMATCH;}
"^="                    (return PREFIXMATCH;)
"$="                    (return SUFFIXMATCH;)
"*="                    (return SUBSTRINGMATCH;)
{string}                {return STRING;}
{ident}                 {return IDENT;}
{ident}"("              {return FUNCTION;}
{num}                   {return NUMBER;}
"#"{name}               {return HASH;}

.                       {return *yytext;}

10. Namespaces and Down-Level Clients

An important issue is the interaction of CSS selectors with XML documents in web clients that were produced prior to this document. Unfortunately, due to the fact that namespaces must be matched based on the URI which identifies the namespace, not the namespace prefix, some mechanism is required to identify namespaces in CSS by their URI as well. Without such a mechanism, it is impossible to construct a CSS stylesheet which will properly match selectors in all cases against a random set of XML documents. However, given complete knowledge of the XML document to which a stylesheet is to be applied, and a limited use of namespaces within the XML document, it is possible to construct a stylesheet in which selectors would match elements and attributes correctly.

It should be noted that a down-level CSS client will (if it properly conforms to CSS forward compatible parsing rules) ignore all @namespace at-rules, as well as all style rules that make use of namespace qualified element type or attribute selectors. The syntax of delimiting namespace prefixes in CSS was deliberately chosen so that down-level CSS clients would ignore the style rules rather than possibly match them incorrectly.

The use of default namespaces in CSS makes it possible to write element type selectors that will function in both namespace aware CSS clients as well as down-level clients. It should be noted that down-level clients may incorrectly match selectors against XML elements in other namespaces.

The following are scenarios and examples in which it is possible to construct stylesheets which would function properly in web clients that do not implement this proposal.

  1. The XML document does not use namespaces.
  2. The XML document defines a single, default namespace used throughout the document. No namespace prefixes are used in element names.
  3. The XML document does not use a default namespace, all namespace prefixes used are known to the stylesheet author and there is a direct mapping between namespace prefixes and namespace URIs (a given prefix may only be mapped to one namespace URI throughout the XML document, there may be multiple prefixes mapped to the same URI).

In other scenarios: when the namespace prefixes used in the XML are not known in advance by the stylesheet author; or a combination of elements with no namespace are used in conjunction with elements using a default namespace; or the same namespace prefix is mapped to different namespace URIs within the same document, or in different documents; it is impossible to construct a CSS stylesheet that will function properly against all elements in those documents, unless, the stylesheet is written using a namespace URI syntax (as outlined in this document or similar) and the document is processed by a CSS and XML namespace aware client.

11. Profiles

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

Non normative examples:

 
W3C 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 universal selector
attribute selectors
:hover, :focus, :lang(), :subject, :target, :enabled, :disabled, :checked and :indeterminate pseudo-classes
structural pseudo-classes
content selectors
child combinator
adjacent direct combinator
adjacent indirect combinator
:before and :after pseudo-elements
:selection and :menu pseudo-elements
Extra constraints - none -

 
 
W3C Selectors profile
Specification CSS level 2
Accepts type selectors
universal selector
attribute selectors
class selectors
ID selectors
:link, :visited, :active, :hover, :focus, :lang() and :first-child pseudo-classes
descendant combinator
child combinator
adjacent direct combinator
all pseudo-elements but :selection and :menu
Excludes content selectors
structural pseudo-classes other than :first-child
:subject and :target pseudo-classes 
adjacent indirect combinator
:selection and :menu pseudo-elements 
Extra constraints - none -

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.

Non normative example:

 
W3C Selectors profile
Specification STTS
Accepts all but excluded simple selectors
Excludes pseudo-elements
dynamic pseudo-classes
:target, :enabled, :disabled, :checked and :indeterminate pseudo-classes
Extra constraints some selectors and combinators are not allowed in fragment descriptions on the right side of STTS declarations.

W3C selectors can be used in STTS in two different manners:

  1. a selection mechanism equivalent to CSS selection mechanism : declarations attached to a given selector are applied to elements matching that selector,
  2. fragment descriptions that appear on the right side of declarations; restriction: selectors and combinators introducing ambiguity about the represented structure (descendant combinator for instance) are not allowed in fragment descriptions.

12. Changes from previous versions

13. Future work

  1. A Character Set section is missing. Two possibilities : add a link to "CSS 3 Module 1 : General Syntax" that will include this information, or add the information to this module.
  2. Need to set up links from occurences of "@namespace" in the current document to the CSS General Syntax Module where will lie the definition of this at-rule.

14. References

  1. [CSS1] Bert Bos, Håkon Wium Lie; "Cascading Style Sheets, level 1", W3C Recommendation, 17 Dec 1996, revised 11 Jan 1999
    (http://www.w3.org/TR/REC-CSS1)
  2. [CSS2] Bert Bos, Håkon Wium Lie, Chris Lilley, Ian Jacobs, editors; "Cascading Style Sheets, level 2", W3C Recommandation, 12 May 1998
    (http://www.w3.org/TR/REC-CSS2)
  3. [STTS3] Daniel Glazman ; "Simple Tree Transformation Sheets 3", Electricité de France, submission to the W3C, 11 Nov 1998
    (http://www.w3.org/TR/NOTE-STTS3)
  4. [ACTIONS] Vidur Apparao, Brendan Eich, Ramanathan Guha, Nisheeth Ranjan ; "Action Sheets : a Modular Way of Defining Behavior for XML and HTML", Netscape Communications Corp., submission to the W3C, 19 June 1998
    (http://www.w3.org/TR/NOTE-AS)
  5. [UI] Tantek Çelik, editor; "User Interface for CSS3", W3C Working Draft, 16 February 2000
    (http://www.w3.org/TR/2000/WD-css3-userint-20000216)
  6. [NMSP] Peter Linss, editor; "CSS Namespace Enhancements (Proposal)", W3C Working Draft, 25 June 1999
    (http://www.w3.org/1999/06/25/WD-css3-namespace-19990625/)