Selectors Level 4

Abstract

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

Selectors Level 4 describes the selectors that already exist in [SELECT], and further introduces new selectors for CSS and other languages that may need them. CSS is a language for describing the rendering of structured documents (such as HTML and XML) on screen, on paper, in speech, etc.

Status of this document

Table of Contents

1 Introduction

This section is not normative.

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

These expressions may be used for many things:

• directly on an element to test whether it matches some criteria, such as in the element.matches() function defined in [DOM]
• applied to an entire tree of elements to filter it into a set of elements that match the criteria, such as in the document.queryAll() function defined in [DOM] or the selector of a CSS style rule.
• used "in reverse" to generate markup that would match a given selector, such as in HAML or Zen Coding

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

1.1 Module Interactions

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

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

2 Selectors Overview

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

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

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

The following table summarizes the Selector syntax:

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

2.1 Fast vs Complete Selector Profiles

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

fast

The fast profile is appropriate for use in any context, including dynamic browser CSS selector matching. It includes every selector defined in this document, except for:

• The :has() pseudo-class

complete

The complete profile is appropriate for contexts which aren’t extremely performance sensitive. For example, the query() method defined in [DOM] should use the complete profile. It includes all of the selectors defined in this document.

CSS implementations conformant to Selectors Level 4 must use the fast profile for CSS selection.

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

3 Selector Syntax and Structure

3.1 Structure and Terminology

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

A selector list is a comma-separated list of selectors; see Selector Lists.

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

A compound selector is a sequence of simple selectors that are not separated by a combinator. If it contains a type selector or universal selector, that selector comes first in the sequence. Only one type selector or universal selector is allowed in the sequence.

A simple selector represents an aspect of an element to be matched against. A simple selector is either a type selector, universal selector, attribute selector, class selector, ID selector, or pseudo-class.

A combinator represents a particular kind of relationship between the elements matched by the compound selectors on either side. Combinators in Selectors level 4 include: whitespace,

Issue: Fill in more combinators.

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

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

3.2 Evaluating a Selector

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

APIs using this algorithm must provide a selector, and one or more element tree root elements indicating the trees that will be searched by the selector. They may optionally provide:

• a scoping method and scoping root. If not specified, the selector defaults to being unscoped.
• a set of :scope elements, for resolving the :scope pseudo-class against. If not specified, the set defaults to being empty.

  If the selector is a relative selector, the set of :scope elements must not be empty.

  Note: Note that if the selector is scoped, the scoping root is automatically taken as the :scope element, so it doesn’t have to be provided explicitly unless a different result is desired.

• which pseudo-elements are allowed to show up in the match list, if any. If not specified, this defaults to allowing all pseudo-elements.

A selector is evaluated against some initial list of elements: the selector match list. The selector match list is initially populated with the element tree roots provided to the algorithm, and all elements reachable from them by traversing any number of child lists.

If the selector is scope-contained, the selector match list is immediately filtered to contain only elements that are either the scoping root or descendants of the scoping root.

The selector is processed from left to right in order, with simple selectors filtering the selector match list, and combinators and pseudo-elements changing the selector match list into something new. If the selector is scope-contained then after each combinator the selector match list must be filtered to contain only elements that are either the scoping root or descendants of the scoping root.

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

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

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

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

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

3.3 Data Model

Selectors are evaluated against a DOM tree. [DOM] Within this specification, this may be referred to as the "document tree".

In addition to the information present in the document tree, for the purpose of selectors, elements are assumed to have arbitrary pseudo-class flags and pseudo-element slots, as defined by the given pseudo-class and pseudo-element.

Four aspects of a DOM element are especially relevant for selectors:

• The element’s type (also known as tagname), which is a pair of strings: a namespace and a local name.
• An ID, which is a string.
• Classes, which are strings.
• Attributes, which are pairs of strings consisting of an attribute name and an attribute value.

These aspects are referred to as features. The simple selectors which are keyed off of them (universal selector, type selectors, ID selectors, class selectors, and attribute selectors) are called feature selectors.

While elements may lack any of the individual features, some elements are featureless, which means that not only do they lack any features (and thus will never match a feature selector), but any selectors that reference features, such as :not(div), also never match them. Thus, only pseudo-classes or pseudo-elements can be used to select them. Individual featureless elements may define additional restrictions on what kinds of selectors can match them.

When matching a selector against a document which is in quirks mode, class and ID selectors must be matched ASCII case-insensitively against the classes and ID of the elements in the document.

3.3.1 Guidance on Mapping Document Languages to DOM

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

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

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

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

Other features of the element should be reflected as features when possible, mapping to something that serves a similar purpose to the same feature in DOM:

type

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

If this "type" can be separated into a "basic" name and a "namespace" that groups names into higher-level groups, that should be reflected in the "namespace" and "local name" divisions of the "type" feature. Otherwise, the "namespace" part should be the empty string, and the entire name should be in the "local name" part.

id

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

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

classes and attributes

Aspects of the element that are useful for identifying the element, but are not generally unique to elements within a document, should be mapped to the "class" or "attribute" features depending on if they’re something equivalent to a "label" (a string by itself) or a "property" (a name/value pair)

pseudo-classes and pseudo-attributes

If any elements match any pseudo-classes or have any pseudo-elements, that must be explicitly defined.

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

3.4 Scoped Selectors

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

There are two scoping methods for selectors:

scope-contained

With this method of scoping, selectors match as if the scoping root were the root of the document: all compound selectors must be represented within the scope. (The :root pseudo-class, however, still only matches the actual root of the document.)

scope-filtered

With this method of scoping, a selector matches an element only if the element is within the scope, even if other components of the selector are outside the scope. (A scoping element is considered to be in scope.)

Note: If there are no :scope elements when a selector is evaluated, the scoping root acts like a :scope element.

3.5 Relative Selectors

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

Relative selectors, once absolutized, can additionally be scope-contained or scope-filtered.

3.5.1 Absolutizing a Relative Selector

To absolutize a relative selector:

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

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

Otherwise:

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

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

3.6 Pseudo-classes

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

The syntax of a pseudo-class is a ":" (U+003A COLON) followed by the name of the pseudo-class, which is either an identifier, or in the case of a functional pseudo-class, a function potentially containing arguments between parentheses (similar to CSS functions).

No white space is allowed between the colon and the name of the pseudo-class, and as usual for CSS syntax, there are no spaces between the function name and its opening parenthesis. As usual for CSS syntax, white space is allowed arond the arguments between the parentheses of a functional pseudo-class, unless otherwise specified.

Pseudo-classes are identical to any other type of simple selector: they’re allowed in all compound selectors contained in a selector, and must follow the type selector or universal selector, if present. Pseudo-class names are ASCII 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.

3.7 Pseudo-elements

Similar to how pseudo-classes represent additional information not directly present in the document tree (or that is inconvenient to use), a pseudo-element is an element not directly present in the document tree, used to create abstractions about the document tree beyond those specified by the document language.

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

Due to legacy constraints, user agents must allow ::before, ::after, ::first-line, and ::first-letter pseudo-elements to be written with a single colon rather than two, similar to pseudo-class syntax. Authors must always use the double-colon syntax for these pseudo-elements.

Pseudo-elements do not exist independently; they belong to another element on the page, called their originating element. When a pseudo-element is encountered in a selector as part of a compound selector, the part of the selector to the left of the pseudo-element selects the originating element for the pseudo-element; the part of the selector to the right, if any, applies to the pseudo-element itself. If a pseudo-element starts a compound selector, it’s treated as if the selector to its left was the universal selector.

Pseudo-elements are featureless, and so can’t be matched by any feature selector. They also do not affect the interpretation of structural pseudo-classes, which are evaluated based solely on real elements. Other pseudo-classes can match pseudo-elements, unless otherwise specified.

I’ve switched over to defaulting to allowing. Is that okay, or should we stick with defaulting to *not* allowing, and requiring individual pseudo-classes to specify that they work on pseudo-elements?

Pseudo-elements may have children, as defined by the specification defining them. Their children can be children of other elements, too, turning the selector match list into a directed acyclic graph, but their rendering must be defined so as to maintain the tree-ness of the box tree.

<div>
  <span>foo</span>
  <"shadow root">
    <content></content>
  </"shadow root">
</div>

The host language defines which pseudo-elements exist and their meaning. [CSS21] defines the ::before, ::after, ::first-line and ::first-letter pseudo-elements which exist in all document languages.

3.7.1 Types of Pseudo-Elements

Pseudo-elements are divided into two categories: content pseudo-elements, text pseudo-elements,

A content pseudo-element “acts like an element”. It might be able to generate boxes (though it probably doesn’t by default), and all properties are valid on it. While it is ignored by structural pseudo-classes, it’s otherwise treated exactly like an element inserted in its place.

A text pseudo-element, on the other hand, never generates boxes. Instead, it generates fragments within the boxes generated by its originating element. Further, the fragments generated by a text pseudo-element can cross content boundaries of elements within the originating element. For these reasons, the properties that apply to text pseudo-elements are extremely restricted.

3.8 Characters and case sensitivity

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

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

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

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

3.9 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 @namespacerule. [CSS3NAMESPACE]

3.10 Invalid Selectors and Error Handling

User agents must observe the rules for handling invalid selectors:

• a parsing error in a selector, e.g. an unrecognized token or a token which is not allowed at the current parsing point, causes that selector to be invalid
• 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.

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.

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

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

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

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

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

4.2 The Matches-Any Pseudo-class: :matches()

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

The :matches() pseudo-class may not be nested within itself or within :not(): :matches(:matches(...)) and :not(:matches(...)) are invalid. Additionally, pseudo-elements cannot be represented by the matches-any pseudo-class; they are not valid within :matches().

Issue: This restriction probably isn’t necessary. If it is, it needs to be expanded, since :has() and :nth-child() have the same functionality as :matches().

Default namespace declarations do not affect any “implied” universal selectors within a :matches() pseudo-class.

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

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

4.3 The Negation Pseudo-class: :not()

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

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

A negation may not be nested within itself or within :matches(): :not(:not(...)) and :matches(:not(...)) are invalid. Additionally, pseudo-elements cannot be represented by the negation pseudo-class; they are not valid within :not().

button:not([DISABLED]) 

*:not(FOO)

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.

4.4 The Relational Pseudo-class: :has()

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

a:has(> img)

dt:has(+ dt)

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

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

5 Elemental selectors

5.1 Type (tag name) 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.

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

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

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.

@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 }

5.2 Universal selector

The universal selector, written as a CSS qualified

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.

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, an attribute selector must be considered to match an element if that element has an attribute that matches the attribute represented by the attribute selector.

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

6.1 Attribute presence and value selectors

CSS2 introduced four attribute selectors:

[att]

Represents an element with the att attribute, whatever the value of the attribute.

''[att=val]''

Represents an element with the att attribute whose value is exactly "val".

''[att~=val]''

Represents an element with the att attribute whose value is a whitespace-separated list of words, one of which is exactly "val". If "val" contains whitespace, it will never represent anything (since the words are separated by spaces). Also if "val" is the empty string, it will never represent anything.

''[att|=val]''

Represents an element with the att attribute, its value either being exactly "val" or beginning with "val" immediately followed by "-" (U+002D). This is primarily intended to allow language subcode matches (e.g., the hreflang attribute on the a element in HTML) as described in BCP 47 ([BCP47]) or its successor. For lang (or xml:lang) language subcode matching, please see the :lang pseudo-class.

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

h1[title]

span[class="example"]

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

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

a[hreflang=fr] 

a[hreflang|="en"] 

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

6.2 Substring matching attribute selectors

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

''[att^=val]''

Represents an element with the att attribute whose value begins with the prefix "val". If "val" is the empty string then the selector does not represent anything.

''[att$=val]''

Represents an element with the att attribute whose value ends with the suffix "val". If "val" is the empty string then the selector does not represent anything.

''[att*=val]''

Represents an element with the att attribute whose value contains at least one instance of the substring "val". If "val" is the empty string then the selector does not represent anything.

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

object[type^="image/"] 

a[href$=".html"] 

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

[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

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

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

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.

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

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

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

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

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

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

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

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

p.pastoral.marine { color: green } 

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.

h1#chapter1 

#chapter1 

*#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 Linguistic Pseudo-classes

7.1 The directionality pseudo-class :dir()

The :dir() pseudo-class allows the author to write selectors that represent an element based on its directionality as determined by the document language. For example, [HTML5] defines how to determine the directionality of an element,

The pseudo-class :dir(ltr) represents an element that

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

7.2 The language pseudo-class :lang()

If the document language specifies how the (human) content language of an element is determined, it is possible to write selectors that represent an element based on its language. The :lang() pseudo-class represents an element that is in one of the languages listed in its argument. It accepts a comma-separated list of one or more language ranges as its argument. Each language range in :lang() must be a valid CSS identifier [CSS21] or consist of an asterisk (* U+002A) immediately followed by an identifier beginning with an ASCII hyphen (U+002D) for the selector to be valid.

The language of an element is defined by the document language. For example, in HTML [HTML401], the language is determined by a

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

Note: It is recommended that documents and protocols indicate language using codes from BCP 47 [BCP47]

html:lang(fr-be)
html:lang(de)
:lang(fr-be) > q
:lang(de) > q

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

<body lang=fr>
  <p>Je suis français.</p>
</body>

Note: Wildcard language matching is new in Level 4.

8 Location Pseudo-classes

8.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?

8.2 The link history pseudo-classes: :link and :visited

User agents commonly display unvisited hyperlinks 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.
• 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.

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

8.3 The target pseudo-class :target

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

URLs with fragment identifiers link to a certain element within the document, known as the target element. For instance, here is a URL

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

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

p.note:target 

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

8.4 The reference element pseudo-class :scope

In some contexts, selectors can be matched with an explicit set of :scope elements. This is is a (potentially empty) set of elements that provide a reference point for selectors to match against,

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

9 User Action Pseudo-classes

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

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

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

a:focus
a:focus:hover

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

9.1 The pointer hover pseudo-class :hover

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

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

Host languages may define additional ways in which an element can match :hover.

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

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

9.2 The activation pseudo-class :active

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

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

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').

9.3 The input focus pseudo-class :focus

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

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

9.4 The drag-and-drop pseudo-class :drop and :drop()

The :drop pseudo-class applies to all elements that are drop targets, as defined by the host language, while the user is “dragging” or otherwise conceptually carrying an item to be “dropped”.

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

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

The keywords have the following meanings:

active

The drop target is the current drop target for the drag operation. That is, if the user were to release the drag, it would be dropped onto this drop target.

valid

If the host language has a concept of “valid” and “invalid” drop targets, this only matches if the drop target is valid for the object currently being dragged. Otherwise, it matches all drop targets. For example, HTML’s dropzone attribute can specify that the drop target only accepts strings or files that are set to a given type.

invalid

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

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

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

10 Time-dimensional Pseudo-classes

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

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

10.1 The current-element pseudo-class :current

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

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

:current(p, li, dt, dd) {
  background: yellow;
}

10.2 The past-element pseudo-class :past

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

10.3 The future-element pseudo-class :future

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

11 The Input Pseudo-classes

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

11.1 Input Control States

11.1.1 The :enabled and :disabled pseudo-classes

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

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

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

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

11.1.2 The mutability pseudo-classes :read-only and :read-write

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

11.1.3 The placeholder-shown pseudo-class :placeholder-shown

Input elements can sometimes show placeholder text as a hint to the user on what to type in.

11.1.4 The default-option pseudo-class :default

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

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

11.2 Input Value States

11.2.1 The selected-option pseudo-class :checked

Radio and checkbox elements can be toggled by the user. Some menu items are "checked" when the user selects them. When such elements are toggled "on" the :checked pseudo-class applies.

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

:not(:checked)

11.2.2 The indeterminate-value pseudo-class :indeterminate

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

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

11.3 Input Value-checking

11.3.1 The validity pseudo-classes: :valid and :invalid

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

Note: There is a difference between an element which has no constraints, and thus would always be :valid, and one which has no data validity semantics at all, and thus is neither :valid nor :invalid.

11.3.2 The range pseudo-classes :in-range and :out-of-range

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

11.3.3 The optionality pseudo-classes :required and :optional

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

11.3.4 The user-interaction pseudo-class :user-error

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

<form>
  <label>
    Volume:
    <input name='vol' type=number min=0 max=10 value=11>
  </label>
  ...
</form>

Issue: Look into :-moz-ui-valid as well.

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.

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

12.2 :empty pseudo-class

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

<p></p>

<foo>bar</foo>

<foo><bar>bla</bar></foo>

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

12.3 :blank pseudo-class

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

<p>
</p>

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

12.4 Child-indexed Pseudo-classes

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

12.4.1 :nth-child() pseudo-class

The :nth-child(An+B [of sel]? ) pseudo-class notation represents an element that has An+B-1 siblings before it in the document tree which match the selector list sel.

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

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

:nth-child(even)   /* represents the 2nd, 4th, 6th, etc elements
:nth-child(10n-1)  /* represents the 9th, 19th, 29th, etc elements */
:nth-child(10n+9)  /* Same */
:nth-child(10n+-1) /* Syntactically invalid, and would be ignored */

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

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

12.4.2 :nth-last-child() pseudo-class

The :nth-last-child(An+B [of sel]? ) pseudo-class notation represents an element that has An+B-1 siblings after it in the document tree which match the selector list sel.

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

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.3 :first-child pseudo-class

The :first-child pseudo-class represents an element that precedes all of its siblings (if any). Same as :nth-child(1).

div > p:first-child

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

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

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

12.4.4 :last-child pseudo-class

The :last-child pseudo-class represents an element that follows all of its siblings (if any). Same as :nth-last-child(1).

ol > li:last-child

12.4.5 :only-child pseudo-class

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

12.5 Typed Child-indexed Pseudo-classes

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

12.5.1 :nth-of-type() pseudo-class

The :nth-of-type(An+B) pseudo-class notation represents an element that has An+B-1 siblings with the same expanded element name before it in the document tree. The CSS Syntax Module [CSS3SYN] defines the An+B notation.

img:nth-of-type(2n+1) { float: right; }
img:nth-of-type(2n) { float: left; }

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

12.5.2 :nth-last-of-type() pseudo-class

The :nth-last-of-type(An+B) pseudo-class notation represents an element that has An+B-1 siblings with the same expanded element name after it in the document tree. The CSS Syntax Module [CSS3SYN] defines the An+B notation.

body > h2:nth-of-type(n+2):nth-last-of-type(n+2) 

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

12.5.3 :first-of-type pseudo-class

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

dl dt:first-of-type

<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.5.4 :last-of-type pseudo-class

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

tr > td:last-of-type

12.5.5 :only-of-type pseudo-class

The :only-of-type pseudo-class represents an element that has no siblings 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.

13 Combinators

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

h1 em

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

div * p

div p *[href]

13.2 Child combinator (>)

A child combinator describes a childhood relationship between two elements. A child combinator is made of the

body > p

div ol>li p

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

13.3 Next-sibling combinator (+)

The next-sibling combinator is made of the “plus sign”

math + p

h1.opener + h2

13.4 Following-sibling combinator (~)

The following-sibling combinator is made of the "tilde"

h1 ~ pre

<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 Grid-Structural Selectors

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

14.1 Column combinator

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

col.selected || td {
  background: gray;
  color: white;
  font-weight: bold;
}

<table>
  <col span="2">
  <col class="selected">
  <tr><td>A <td>B <td>C
  <tr><td colspan="2">D <td>E
  <tr><td>F <td colspan="2">G
</table>

14.2 :nth-column() pseudo-class

The :nth-column(An+B) pseudo-class notation represents a cell element belonging to a column that has An+B-1 columns before it, for any positive

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

14.3 :nth-last-column() pseudo-class

The :nth-last-column(An+B) pseudo-class notation represents a cell element belonging to a column that has An+B-1 columns after it, for any positive

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

15 Calculating a selector’s specificity

A selector’s specificity is calculated for a given element 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

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

In most cases, a selector has the same specificity for every element it applies to. The specificity of a :matches() pseudo-class, however, is the specificity of the most specific complex selector that matched the given element. (The full selector’s specificity is equivalent to expanding out all the combinations in full, without :matches().) The specificity of a :not() pseudo-class is the specificity of the most specifc complex selector in its selector list. In either case, the pseudo-class itself does not contribute any additional specificity. For example, :matches(em, strong) has a specificity of (0,0,1), like a tag selector.

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

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

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

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

Note: The specificity of the styles

16 Grammar

Issue: Rewrite this whole danged thing in terms of Syntax parsing algos instead.

The grammar below defines the syntax of Selectors. It is applied to a stream of tokens, as returned by the tokenizer defined in [CSS3SYN]. 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
• +: 1 or more
• ?: 0 or 1
• |: separates alternatives
• [ ]: grouping

The productions in uppercase are defined by CSS Syntax [CSS3SYN], and correspond to the tokens of the same name. Literal strings correspond to delim tokens with the given value. Unlike other grammars in CSS, whitespace is not ignored The production "S" represents a whitespace token. The wqname_prefix production comes from the Namespaces spec [CSS3NAMESPACE]

The productions are:

  complex_selector_list
    : complex_selector [ COMMA S* complex_selector ]*
    ;

  scope_relative_selector_list
    : scope_relative_selector [ COMMA s* scope_relative_selector ]*

  scope_relative_selector
    : combinator? complex_selector
    ;

  complex_selector
    : compound_selector [ combinator compound_selector ]* S*
    ;

  combinator
    /* combinators can be surrounded by whitespace */
    : S+ | S* [ '>' | '+' | '~' | COLUMN | '/' IDENT '/' ] S*
    ;

  compound_selector_list
    : compound_selector S* [ COMMA S* compound_selector ]* S*

  compound_selector
    : type_selector [ id | class | attrib | pseudo ]*
      | [ id | class | attrib | pseudo ]+
    ;

  simple_selector_list
    : simple_selector S* [ COMMA S* simple_selector ] S*

  simple_selector
    : type_selector | id | class | attrib | pseudo

  type_selector
    : wqname_prefix? element_name
    ;

  element_name
    : IDENT | '*'
    ;

  id
    : HASH
    ;

  class
    : '.' IDENT
    ;

  attrib
    : '[' S* attrib_name ']'
      | '[' S* attrib_name attrib_match [ IDENT | STRING ] S* attrib_flags? ']'
    ;

  attrib_name
    : wqname_prefix? IDENT S*

  attrib_match
    : [ '=' |
        PREFIX-MATCH |
        SUFFIX-MATCH |
        SUBSTRING-MATCH |
        INCLUDE-MATCH |
        DASH-MATCH
      ] S*

  attrib_flags
    : IDENT 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* value ')'
    ;

To aid with the authoring of property grammars, the following CSS grammar productions are defined:

<selector>

A complex_selector_list production representing a selector list.

<relative-selector>

A scope_relative_selector_list production representing a selector list comprised of relative selectors.

<compound-selector>

A compound_selector_list production representing a selector list comprised of compound selectors.

<id-selector>

An id production representing an ID selector

17 API Hooks

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

17.1 Parse A Selector

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

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

17.2 Parse A Relative Selector

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

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

18 Changes

Significant changes since the 2 May 2013 Working Draft include:

• Split out relative selectors from scoped selectors, as these are different concepts that can be independently invoked.

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

Conformance

Document conventions

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

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

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

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.

Conformance classes

Conformance to this specification is defined for three conformance classes:

style sheet

A CSS style sheet.

renderer

A UA that interprets the semantics of a style sheet and renders documents that use them.

authoring tool

A UA that writes a style sheet.

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

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

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

Partial implementations

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

Experimental implementations

To avoid clashes with future CSS features, the CSS2.1 specification reserves a prefixed syntax for proprietary and experimental extensions to CSS.

Prior to a specification reaching the Candidate Recommendation stage in the W3C process, all implementations of a CSS feature are considered experimental. The CSS Working Group recommends that implementations use a vendor-prefixed syntax for such features, including those in W3C Working Drafts. This avoids incompatibilities with future changes in the draft.

Non-experimental implementations

Once a specification reaches the Candidate Recommendation stage, non-experimental implementations are possible, and implementors should release an unprefixed implementation of any CR-level feature they can demonstrate to be correctly implemented according to spec.

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

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

References

Normative References

Informative References

Index

Property index

Issues Index