Copyright © 2013 W3C® (MIT, ERCIM, Keio, Beihang), All Rights Reserved. W3C liability, trademark and document use rules apply.
Selectors are patterns that match against elements in a tree, and as such form one of several technologies that can be used to select nodes in an XML document. Selectors have been optimized for use with HTML and XML, and are designed to be usable in performance-critical code. They are a core component of CSS (Cascading Style Sheets), which uses Selectors to bind style properties to elements in the document.
Selectors Level 4 describes the selectors that already exist in [SELECT], and further introduces new selectors for CSS and other languages that may need them.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
The (archived) public mailing list<EMAIL_ADDRESS>(see instructions) is preferred for discussion of this specification. When sending e-mail, please put the text “selectors4” in the subject, preferably like this: “[selectors4] …summary of comment…”
This document was produced by the CSS Working Group (part of the Style Activity).
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This module is a somewhat-unstable Working Draft. If you are looking for a stable Selectors specification, use Selectors 3. Read the CSS Snapshot for an overview of the CSS development process. See the Selectors Overview for a summary of additions to level 3.
The following features are at-risk and may be dropped during the CR
period if there is not sufficient implementer interest: the reference
combinator, the column combinator, the ‘:invalid-drop
’ and ‘:valid-drop
’ pseudo-classes.
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:
Element.matches()
function defined in [SELECTORS-API2]
document.findAll()
function defined in [SELECTORS-API2] or the
selector of a CSS style rule.
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.
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.
This section is non-normative, as it merely summarizes the following sections.
A Selector represents a structure. This structure can be used as a condition (e.g. in a CSS rule) that determines which elements a selector matches in the document tree, or as a flat description of the HTML or XML fragment corresponding to that structure.
Selectors may range from simple element names to rich contextual representations.
The following table summarizes the Selector syntax:
| Pattern | Represents | Section | Level |
|---|---|---|---|
*
| any element | Universal selector | 2 |
E
| an element of type E | Type (tag name) selector | 1 |
E:not(s1, s2)
| an E element that does not match either compound selector s1 or compound selector s2 | Negation pseudo-class | 3/4 |
E:matches(s1, s2)
| an E element that matches compound selector s1 and/or compound selector s2 | Matches-any pseudo-class | 4 |
E.warning
| an E element belonging to the class warning (the
document language specifies how class is determined).
| Class selectors | 1 |
E#myid
| an E element with ID equal to myid .
| ID selectors | 1 |
E[foo]
| an E element with a foo attribute
| Attribute selectors | 2 |
E[foo="bar"]
| an E element whose foo attribute value is exactly equal
to bar
| Attribute selectors | 2 |
E[foo="bar" i]
| an E element whose foo attribute value is exactly equal
to any (ASCII-range) case-permutation of bar
| Attribute selectors: Case-sensitivity | 4 |
E[foo~="bar"]
| an E element whose foo attribute value is a list of
whitespace-separated values, one of which is exactly equal to
bar
| 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 attribute value contains the
substring bar
| Attribute selectors | 3 |
E[foo|="en"]
| an E element whose foo attribute value is a
hyphen-separated list of values beginning with en
| Attribute selectors | 2 |
E:dir(ltr)
| an element of type E in with left-to-right directionality (the document language specifies how directionality is determined) | The :dir() pseudo-class | 4 |
E:lang(zh, *-hant)
| an element of type E tagged as being either in Chinese (any dialect or writing system) or othewise written with traditional Chinese characters | The :lang() pseudo-class | 2/4 |
E:any-link
| an E element being the source anchor of a hyperlink | The hyperlink pseudo-class | 4 |
E:link
| an E element being the source anchor of a hyperlink of which the target is not yet visited | The link history pseudo-classes | 1 |
E:visited
| an E element being the source anchor of a hyperlink of which the target is already visited | The link history pseudo-classes | 1 |
E:local-link
| an E element being the source anchor of a hyperlink of which the target is the current document | The local link pseudo-class | 4 |
E:local-link(0)
| an E element being the source anchor of a hyperlink of which the target is within the current domain | The local link pseudo-class | 4 |
E:target
| an E element being the target of the referring URL | The target pseudo-class | 3 |
E:scope
| an E element being a designated contextual reference element | The scope pseudo-class | 4 |
E:current
| an E element that is currently presented in a time-dimensional canvas | Time-dimensional Pseudo-classes | 4 |
E:current(s)
| an E element that is the deepest :current element that matches
selector s
| Time-dimensional Pseudo-classes | 4 |
E:past
| an E element that is in the past in a time-dimensional canvas | Time-dimensional Pseudo-classes | 4 |
E:future
| an E element that is in the future in a time-dimensional canvas | Time-dimensional Pseudo-classes | 4 |
E:active
| an E element that is in an activated state | The user action pseudo-classes | 1 |
E:hover
| an E element that is under the cursor, or that has a descendant under the cursor | The user action pseudo-classes | 2 |
E:focus
| an E element that has user input focus | The user action pseudo-classes | 2 |
E:enabled
| a user interface element E that is enabled or disabled, respectively | The :enabled and :disabled pseudo-classes | 3 |
E:checked
| a user interface element E that is checked/selected (for instance a radio-button or checkbox) | The selected-option pseudo-class | 3 |
E:indeterminate
| a user interface element E that is in an indeterminate state (neither checked nor unchecked) | The indeterminate-value pseudo-class | 4 |
E:default
| a user interface element E that | The default option pseudo-class :default | 3-UI/4 |
E:in-range E:out-of-range
| a user interface element E that | The validity pseudo-classes | 3-UI/4 |
E:required E:optional
| a user interface element E that | The optionality pseudo-classes | 3-UI/4 |
E:read-only E:read-write
| a user interface element E that | The mutability pseudo-classes | 3-UI/4 |
E:root
| an E element, root of the document | Structural pseudo-classes | 3 |
E:empty
| an E element that has no children (not even text nodes) | Structural pseudo-classes | 3 |
E:first-child
| an E element, first child of its parent | Structural pseudo-classes | 2 |
E:nth-child(n)
| an E element, the n-th child of its parent | Structural pseudo-classes | 3 |
E:last-child
| an E element, last child of its parent | Structural pseudo-classes | 3 |
E:nth-last-child(n)
| an E element, the n-th child of its parent, counting from the last one | Structural pseudo-classes | 3 |
E:only-child
| an E element, only 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:nth-of-type(n)
| an E element, the n-th 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:nth-last-of-type(n)
| an E element, the n-th sibling of its type, counting from the last one | Structural pseudo-classes | 3 |
E:only-of-type
| an E element, only sibling of its type | Structural pseudo-classes | 3 |
E:nth-match(n of selector)
| an E element, the n-th sibling matching selector | Structural pseudo-classes | 4 |
E:nth-last-match(n of selector)
| an E element, the n-th sibling matching selector, counting from the last one | Structural pseudo-classes | 4 |
E:column(selector)
| an E element that represents a cell in a grid/table belonging to a column represented by an element that matches selector | Grid-Structural pseudo-classes | 4 |
E:nth-column(n)
| an E element that represents a cell belonging to the nth column in a grid/table | Grid-Structural pseudo-classes | 4 |
E:nth-last-column(n)
| an E element that represents a cell belonging to the nth column in a grid/table, counting from the last one | Grid-Structural pseudo-classes | 4 |
E F
| an F element descendant of an E element | Descendant combinator | 1 |
E > F
| an F element child of an E element | Child combinator | 2 |
E + F
| an F element immediately preceded by an E element | Next-sibling combinator | 2 |
E ~ F
| an F element preceded by an E element | Following-sibling combinator | 3 |
E /foo/ F
| an F element ID-referenced by an E element's foo
attribute
| Reference combinator | 4 |
E! > F
| an E element parent of an F element | Determining the subject of a selector + Child combinator | 4 |
Some Level 4 selectors (noted above as "3-UI") were introduced in [CSS3UI].
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:
:matches()
, :not()
, :nth-match()
, and :nth-last-match()
.
We are considering whether this restriction should be lifted.
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 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 chain of one or more compound selectors separated by combinators.
A compound selector is a chain of simple selectors that are not separated by a combinator. It always begins with a type selector or a (possibly implied) universal selector. No other type selector or universal selector is allowed in the sequence.
A simple selector is either a type selector, universal selector, attribute selector, class selector, ID selector, or pseudo-class.
A combinator is punctuation that represents a
particular kind of relationship between the compound selectors on either side. Combinators
in Selectors level 4 include: whitespace, "greater-than sign"
(U+003E, >
), "plus sign" (U+002B, +
)
and "tilde" (U+007E, ~
). White space may appear between a combinator and the
simple selectors around it.
An empty selector, containing no compound selector, is an invalid selector.
The elements of a document tree that are represented by a selector are the subjects of the selector.
By default, the subjects of a selector are the elements represented by the last compound selector in the selector. Thus a selector consisting of a single compound selector represents any element satisfying its requirements Prepending another compound selector and a combinator to a sequence imposes additional matching constraints, so the subjects of the selector are always a subset of the elements represented by the last compound selector.
As a feature of the complete Selectors profile, the subject of the selector can be explicitly identified by prepending an exclamation mark (!) to one of the compound selectors in a selector. Although the element structure that the selector represents is the same with or without the exclamation mark, indicating the subject in this way can change which compound selector represents the subject in that structure.
Should the exclamation mark be prepended or appended to the subject? Or both? Or prepend two, to avoid the "! = not" issue?
For example, the following selector represents a list item
LI
unique child of an ordered list OL
:
OL > LI:only-child
However the following one represents an ordered list OL
having a unique child, that child being a LI
:
!OL > LI:only-child
The tree structures represented by these two selectors are the same, but the subjects of the selectors are not.
Some host applications may choose to scope selectors
to a particular subtree of the document. The root of the scoping subtree
is called the scoping element, and is
in-scope. When scoped selectors are used, it forms the contextual reference element
set and matches the :scope
pseudo-class.
There are three methods of scoping selectors:
:root
pseudo-class, however, still
only matches the actual root of the document.)
: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. The scoping element matches
this implied :scope
selector,
but does not limit which elements match.
Scope-relative selectors must be absolutized before using them for matching.
It might be necessary (for, e.g.
::distributed()
or documentFragment.find()
),
to split the concept of scope-relative selector into multiple concepts.
For example, the element.querySelector()
function defined
in [SELECTORS-API2] allows the
author to define a scope-filtered
selector, while the similar element.find
function defined in
the same spec uses scope-relative
selectors.
On the other hand, the selectors within an [HTML5] scoped stylesheet define scope-contained selectors.
To absolutize a scope-relative selector:
:scope
as the initial compound selector.
:scope
pseudo-class (either at the
top-level or as an argument to a functional pseudo-class), prepend :scope
followed by the descendant combinator.
To absolutize a scope-relative selector list, absolutize each scope-relative selector in the list.
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.
A pseudo-class always consists of a
“colon” (:
) followed by the name of the pseudo-class and, for functional pseudo-classes, by one or
more arguments between parentheses (similar to CSS functions). White space
is optionally allowed between the parentheses and the argument, but not
between the pseudo-class name and the parentheses. If arguments are
separated by commas, white space is optionally allowed before/after each
comma.
Pseudo-classes are allowed in all compound selectors contained in a selector. Pseudo-classes are allowed anywhere in a compound selector after the leading type selector or (possibly omitted) universal selector. Pseudo-class names are 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.
Dynamic pseudo-classes classify elements on characteristics other than their name, attributes, or content, but rather on characteristics that cannot be deduced from the document tree. They do not appear in or modify the document source or document tree.
Pseudo-elements create
abstractions about the document tree beyond those specified by the
document language. For instance, document languages do not offer
mechanisms to access the first letter or first line of an element's
content. Pseudo-elements allow
authors to refer to this otherwise inaccessible information. Pseudo-elements may also provide authors
a way to refer to content that does not exist in the source document
(e.g., the ::before
and ::after
pseudo-elements give access to generated
content in CSS [CSS21]).
A pseudo-element is made of two
colons (::
) followed by the name of the pseudo-element. Pseudo-element names are ASCII case-insensitive.
This ::
notation was chosen in order to establish a
discrimination between pseudo-classes
(which subclass existing elements) and pseudo-elements (which are elements not
represented in the document tree). However, for compatibility with
existing style sheets, user agents must also accept the previous one-colon
notation for pseudo-elements
introduced in CSS levels 1 and 2 (namely, :first-line
,
:first-letter
, :before
and :after
).
This compatibility notation is not allowed any other pseudo-elements.
A future version of this specification may allow multiple pseudo-elements per selector.
Syntactically, a pseudo-element immediately follows the compound selector representing its originating element, i.e. the element to which it is associated. Unless otherwise overridden by the definition of the pseudo-element:
A pseudo-element may be immediately followed by any combination of the user action pseudo-classes, in which case the pseudo-element is represented only when it is in the corresponding state. Whether these pseudo-classes can match on the pseudo-element depends on the pseudo-class and pseudo-element”s definitions: unless otherwise-specified, none of these pseudo-classes will match on the pseudo-element.
For example, the :hover
pseudo-class specifies that it can apply to any pseudo-element, i.e.
::first-line:hover
will match when the first line is
hovered. However, since neither :focus
nor
::first-line
define that :focus
can apply to
::first-line
, the selector ::first-line:focus
will never match anything.
The host language defines which pseudo-elements exist and their meaning. For CSS, [CSS21] defines the ::before, ::after, ::first-line and ::first-letter pseudo-elements.
All Selectors syntax is case-insensitive within the ASCII range (i.e.
[a-z] and [A-Z] are equivalent), except for the following parts, which are
not under the control of Selectors: the case-sensitivity of document
language element names, attribute names, and attribute values depends on
the document language. For example, in HTML,
element names are case-insensitive, but in XML, they are
case-sensitive. Case sensitivity of namespace prefixes is defined in [CSS3NAMESPACE]. Case
sensitivity of language ranges is
defined in the :lang()
section.
White space in Selectors consists of the characters SPACE (U+0020), TAB (U+0009), LINE FEED (U+000A), CARRIAGE RETURN (U+000D), and FORM FEED (U+000C) can occur in whitespace. Other space-like characters, such as EM SPACE (U+2003) and IDEOGRAPHIC SPACE (U+3000), are never part of white space.
Characters in Selectors can be escaped with a backslash according to the
same escaping
rules as CSS. [CSS21] Note that escaping a
character "cancels out" any special meaning it may have in Selectors. For
example, the selector ‘#foo>a
’ contains a
combinator, but ‘#foo\>a
’ instead selects an
element with the id foo>a
.
Certain selectors support namespace prefixes. The mechanism by which
namespace prefixes are declared should be specified
by the language that uses Selectors. If the language does not specify a
namespace prefix declaration mechanism, then no prefixes are declared. In
CSS, namespace prefixes are declared with the @namespace
rule. [CSS3NAMESPACE]
User agents must observe the rules for handling invalid selectors:
An invalid selector represents nothing.
A comma-separated list of selectors represents the union of all elements selected by each of the individual selectors in the selector list. (A comma is U+002C.) For example, in CSS when several selectors share the same declarations, they may be grouped into a comma-separated list. White space may appear before and/or after the comma.
CSS example:
In this example, we condense three rules with identical declarations into one. Thus,
h1 { font-family: sans-serif } h2 { font-family: sans-serif } h3 { font-family: sans-serif }
is equivalent to:
h1, h2, h3 { font-family: sans-serif }
Warning: the equivalence is true in this example because all the selectors are valid selectors. If just one of these selectors were invalid, the entire selector list would be invalid. This would invalidate the rule for all three heading elements, whereas in the former case only one of the three individual heading rules would be invalidated.
Invalid CSS example:
h1 { font-family: sans-serif } h2..foo { font-family: sans-serif } h3 { font-family: sans-serif }
is not equivalent to:
h1, h2..foo, h3 { font-family: sans-serif }
because the above selector (h1, h2..foo, h3
) is entirely
invalid and the entire style rule is dropped. (When the selectors are not
grouped, only the rule for h2..foo
is dropped.)
: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.
In the fast Selectors profile, only
lists of compound selectors are allowed
within :matches()
: combinators are not allowed. In the complete profile, full complex selectors are allowed.
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()
.
Default namespace declarations do not affect any “implied” universal
selectors within a :matches()
pseudo-class.
For example, following selector matches any element that is being hovered or focused, regardless of its namespace. In particular, it is not limited to only matching elements in the default namespace that are being hovered or focused.
*|*:matches(:hover, :focus)
The following selector, however, represents only hovered or focused
elements that are in the default namespace, because it uses an explicit
universal selector within the :matches()
notation:
*|*:matches(*:hover, *:focus)
: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.
In the fast Selectors profile, only
lists of compound selectors are allowed
within :not()
: combinators are not allowed. In the complete profile, full complex selectors are allowed.
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()
.
For example, the following selector matches all button
elements in an HTML document that are not disabled.
button:not([DISABLED])
The following selector represents all but FOO
elements.
*:not(FOO)
The following compound selector represents all HTML elements except links.
html|*:not(:link):not(:visited)
Default namespace declarations do not affect the subject of any selector
within a negation pseudo-class unless the argument is an explicit
universal selector or a type selector. (See :matches()
for examples.)
Note: the :not() pseudo allows useless
selectors to be written. For instance :not(*|*)
, which represents no
element at all, or foo:not(bar)
, which is equivalent to
foo
but with a higher specificity.
A type selector is the name of a document language element type written using the syntax of CSS qualified names [CSS3NAMESPACE]. A type selector represents an instance of the element type in the document tree.
Example:
The following selector represents an h1
element in the
document tree:
h1
Type selectors allow an optional namespace component: a namespace prefix
that has been previously declared may be prepended
to the element name separated by the namespace separator "vertical
bar" (U+007C, |
). (See, e.g., [XML-NAMES] for the use of
namespaces in XML.)
The namespace component may be left empty (no prefix before the namespace separator) to indicate that the selector is only to represent elements with no namespace.
An asterisk may be used for the namespace prefix, indicating that the selector represents elements in any namespace (including elements with no namespace).
Element type selectors that have no namespace component (no namespace
separator) represent elements without regard to the element's namespace
(equivalent to "*|
") unless a default namespace has been declared for namespaced selectors (e.g. in CSS, in the
style sheet). If a default namespace has been declared, such selectors
will represent only elements in the default namespace.
A type selector containing a namespace prefix that has not been previously declared for namespaced selectors is an invalid selector.
In a namespace-aware client, the name part of element type selectors (the part after the namespace separator, if it is present) will only match against the local part of the element's qualified name.
In summary:
ns|E
*|E
|E
E
CSS examples:
@namespace foo url(http://www.example.com); foo|h1 { color: blue } /* first rule */ foo|* { color: yellow } /* second rule */ |h1 { color: red } /* ...*/ *|h1 { color: green } h1 { color: green }
The first rule (not counting the @namespace
at-rule) will
match only h1
elements in the "http://www.example.com"
namespace.
The second rule will match all elements in the "http://www.example.com" namespace.
The third rule will match only h1
elements with no
namespace.
The fourth rule will match h1
elements in any namespace
(including those without any namespace).
The last rule is equivalent to the fourth rule because no default namespace has been defined.
The universal selector, written as a
CSS qualified
name [CSS3NAMESPACE] with an
asterisk (*
U+002A) as the local name, represents the
qualified name of any element type. It represents any single element in
the document tree in any namespace (including those without a namespace)
if no default namespace has been specified for selectors. If a default
namespace has been specified, see Universal selector
and Namespaces below.
If a universal selector represented by *
(i.e. without a
namespace prefix) is not the only component of a compound selector or is immediately followed
by a pseudo-element, then the
*
may be omitted and the universal selector's presence
implied.
Examples:
*[hreflang|=en]
and [hreflang|=en]
are
equivalent,
*.warning
and .warning
are equivalent,
*#myid
and #myid
are equivalent.
Note: it is recommended that the
*
not be omitted, because it decreases the potential
confusion between, for example, div
:first-child
and div:first-child
. Here, div *:first-child
is more readable.
The universal selector allows an optional namespace component. It is used as follows:
ns|*
*|*
|*
*
A universal selector containing a namespace prefix that has not been previously declared is an invalid selector.
Selectors allow the representation of an element's attributes. When a selector is used as an expression to match against an element, an attribute selector must be considered to match an element if that element has an attribute that matches the attribute represented by the attribute selector.
Add comma-separated syntax for multiple-value matching? e.g. [rel ~= next, prev, up, first, last]
CSS2 introduced four attribute selectors:
[att]
att
attribute, whatever
the value of the attribute.
[att=val]
att
attribute whose value
is exactly "val".
[att~=val]
att
attribute whose value
is a whitespace-separated list of words, one of
which is exactly "val". If "val" contains whitespace, it will never
represent anything (since the words are separated by spaces).
Also if "val" is the empty string, it will never represent anything.
[att|=val]
att
attribute, its value
either being exactly "val" or beginning with "val" immediately followed
by "-" (U+002D). This is primarily intended to allow language subcode
matches (e.g., the hreflang
attribute on the a
element in HTML) as described in BCP 47 ([BCP47]) or its
successor. For lang
(or xml:lang
) language
subcode matching, please see the
:lang
pseudo-class.
Attribute values must be CSS identifiers or strings. [CSS21]
Examples:
The following attribute selector represents an h1
element
that carries the title
attribute, whatever its value:
h1[title]
In the following example, the selector represents a span
element whose class
attribute has exactly the value
"example":
span[class="example"]
Multiple attribute selectors can be used to represent several
attributes of an element, or several conditions on the same attribute.
Here, the selector represents a span
element whose
hello
attribute has exactly the value "Cleveland" and whose
goodbye
attribute has exactly the value "Columbus":
span[hello="Cleveland"][goodbye="Columbus"]
The following CSS rules illustrate the differences between "=" and
"~=". The first selector would match, for example, an a
element with the value "copyright copyleft
copyeditor" on a rel
attribute. The second selector would
only match an a
element with an
href
attribute having the exact value "http://www.w3.org/".
a[rel~="copyright"] { ... } a[href="http://www.w3.org/"] { ... }
The following selector represents an a
element whose hreflang
attribute is exactly "fr".
a[hreflang=fr]
The following selector represents an a
element for which the value of the hreflang
attribute begins
with "en", including "en", "en-US", and "en-scouse":
a[hreflang|="en"]
The following selectors represent a DIALOGUE
element
whenever it has one of two different values for an attribute
character
:
DIALOGUE[character=romeo] DIALOGUE[character=juliet]
Three additional attribute selectors are provided for matching substrings in the value of an attribute:
[att^=val]
att
attribute whose value
begins with the prefix "val". If "val" is the empty string then the
selector does not represent anything.
[att$=val]
att
attribute whose value
ends with the suffix "val". If "val" is the empty string then the
selector does not represent anything.
[att*=val]
att
attribute whose value
contains at least one instance of the substring "val". If "val" is the
empty string then the selector does not represent anything.
Attribute values must be CSS identifiers or strings. [CSS21]
Examples:
The following selector represents an HTML object
,
referencing an image:
object[type^="image/"]
The following selector represents an HTML anchor a
with an href
attribute whose
value ends with ".html".
a[href$=".html"]
The following selector represents an HTML paragraph with a
title
attribute whose value contains the substring "hello"
p[title*="hello"]
By default case-sensitivity of attribute names and values in selectors
depends on the document language. To match attribute values
case-insensitively regardless of document language rules, the attribute
selector may include the identifier i
before the closing
bracket (]
). When this flag is present, UAs must match the
attribute's value case-insensitively within the ASCII range.
The following rule will style the frame
attribute when it
has a value of hsides
, whether that value is represented as
hsides
, HSIDES
, hSides
, etc. even
in an XML environment where attribute values are case-sensitive.
[frame=hsides i] { border-style: solid none; }
The attribute name in an attribute selector is given as a CSS qualified
name: a namespace prefix that has been previously declared may be prepended to the attribute name
separated by the namespace separator "vertical bar"
(|
). In keeping with the Namespaces in the XML
recommendation, default namespaces do not apply to attributes, therefore
attribute selectors without a namespace component apply only to attributes
that have no namespace (equivalent to "|attr
"). An asterisk
may be used for the namespace prefix indicating that the selector is to
match all attribute names without regard to the attribute's namespace.
An attribute selector with an attribute name containing a namespace prefix that has not been previously declared is an invalid selector.
CSS examples:
@namespace foo "http://www.example.com"; [foo|att=val] { color: blue } [*|att] { color: yellow } [|att] { color: green } [att] { color: green }
The first rule will match only elements with the attribute
att
in the "http://www.example.com" namespace with the value
"val".
The second rule will match only elements with the attribute
att
regardless of the namespace of the attribute (including
no namespace).
The last two rules are equivalent and will match only elements with the
attribute att
where the attribute is not in a namespace.
Attribute selectors represent attribute values in the document tree. How that document tree is constructed is outside the scope of Selectors. In some document formats default attribute values can be defined in a DTD or elsewhere, but these can only be selected by attribute selectors if they appear in the document tree. Selectors should be designed so that they work whether or not the default values are included in the document tree.
For example, a XML UA may, but is not required to, read an “external subset” of the DTD, but is required to look for default attribute values in the document's “internal subset”. (See, e.g., [XML10] for definitions of these subsets.) Depending on the UA, a default attribute value defined in the external subset of the DTD might or might not appear in the document tree.
A UA that recognizes an XML namespace may, but is not required to use its knowledge of that namespace to treat default attribute values as if they were present in the document. (For example, an XHTML UA is not required to use its built-in knowledge of the XHTML DTD. See, e.g., [XML-NAMES] for details on namespaces in XML 1.0.)
Note: Typically, implementations choose to ignore external subsets. This corresponds to the behaviour of non-validating processors as defined by the XML specification.
Example:
Consider an element EXAMPLE
with an attribute
radix
that has a default value of "decimal"
.
The DTD fragment might be
<!ATTLIST EXAMPLE radix (decimal,octal) "decimal">
If the style sheet contains the rules
EXAMPLE[radix=decimal] { /*... default property settings ...*/ } EXAMPLE[radix=octal] { /*... other settings...*/ }
the first rule might not match elements whose radix
attribute is set by default, i.e. not set explicitly. To catch all cases,
the attribute selector for the default value must be dropped:
EXAMPLE { /*... default property settings ...*/ } EXAMPLE[radix=octal] { /*... other settings...*/ }
Here, because the selector EXAMPLE[radix=octal]
is more
specific than the type selector alone, the style declarations in the
second rule will override those in the first for elements that have a
radix
attribute value of "octal"
. Care has to
be taken that all property declarations that are to apply only to the
default case are overridden in the non-default cases' style rules.
The class selector is given as a full stop
(. U+002E) immediately followed by an identifier. It represents an element
belonging to the class identified by the identifier, as defined by the
document language. For example, in [HTML5], [SVG11], and [MATHML] membership in a class is
given by the class
attribute: in these languages it is
equivalent to the ~=
notation applied to the local
class
attribute (i.e.
[class~=identifier]
).
CSS examples:
We can assign style information to all elements with
class~="pastoral"
as follows:
*.pastoral { color: green } /* all elements with class~=pastoral */
or just
.pastoral { color: green } /* all elements with class~=pastoral */
The following assigns style only to H1 elements with
class~="pastoral"
:
H1.pastoral { color: green } /* H1 elements with class~=pastoral */
Given these rules, the first H1
instance below would not
have green text, while the second would:
<H1>Not green</H1> <H1 class="pastoral">Very green</H1>
The following rule matches any P
element whose
class
attribute has been assigned a list of whitespace-separated values that includes both
pastoral
and marine
:
p.pastoral.marine { color: green }
This rule matches when class="pastoral blue aqua marine"
but does not match for class="pastoral blue"
.
Note: Because CSS gives considerable power
to the "class" attribute, authors could conceivably design their own
"document language" based on elements with almost no associated
presentation (such as DIV
and SPAN
in HTML) and
assigning style information through the "class" attribute. Authors should
avoid this practice since the structural elements of a document language
often have recognized and accepted meanings and author-defined classes may
not.
Note: If an element has multiple class attributes, their values must be concatenated with spaces between the values before searching for the class. As of this time the working group is not aware of any manner in which this situation can be reached, however, so this behavior is explicitly non-normative in this specification.
Document languages may contain attributes that are declared to be of
type ID. What makes attributes of type ID special is that no two such
attributes can have the same value in a conformant document, regardless of
the type of the elements that carry them; whatever the document language,
an ID typed attribute can be used to uniquely identify its element. In
HTML all ID attributes are named id
; XML applications may
name ID attributes differently, but the same restriction applies. Which
attribute on an element is considered the “ID attribute“ is defined by
the document language.
An ID selector consists of a “number sign”
(U+0023, #
) immediately followed by the ID value, which must
be a CSS identifier.
An ID selector represents an element instance that has an identifier that
matches the identifier in the ID selector. (It is possible in
non-conforming documents for multiple elements to match a single ID
selector.)
In Quirks Mode, we accept all hash tokens, not just ones whose value matches the ident syntax. Should we change the Standards Mode to do that, too? Note that HTML5 loosened the definition of valid ids to allow things starting with numbers, etc.
Examples:
The following ID selector represents an h1
element whose
ID-typed attribute has the value "chapter1":
h1#chapter1
The following ID selector represents any element whose ID-typed attribute has the value "chapter1":
#chapter1
The following selector represents any element whose ID-typed attribute has the value "z98y".
*#z98y
Note: In XML 1.0 [XML10], the information about which
attribute contains an element's IDs is contained in a DTD or a schema.
When parsing XML, UAs do not always read the DTD, and thus may not know
what the ID of an element is (though a UA may have namespace-specific
knowledge that allows it to determine which attribute is the ID attribute
for that namespace). If a style sheet author knows or suspects that a UA
may not know what the ID of an element is, he should use normal attribute
selectors instead: [name=p371]
instead of #p371
.
If an element has multiple ID attributes, all of them must be treated as IDs for that element for the purposes of the ID selector. Such a situation could be reached using mixtures of xml:id, DOM3 Core, XML DTDs, and namespace-specific knowledge.
:any-link
The :any-link pseudo-class represents an
element that acts as the source anchor of a hyperlink. For example, in [HTML5], any
<a>
, <area>
, or <link>
elements with an href
attribute are hyperlinks, and thus match
:any-link
. It matches an element if the element would
match :link
or :visited
, equivalent to ‘:matches(:link, :visited)
’.
Any better name suggestions for this pseudo?
: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:
:link
pseudo-class applies
to links that have not yet been visited.
:visited
pseudo-class
applies once the link has been visited by the user.
After some amount of time, user agents may choose to return a visited
link to the (unvisited) ‘:link
’ state.
The two states are mutually exclusive.
Example:
The following selector represents links carrying class
footnote
and already visited:
.footnote:visited
Note: It is possible for style sheet authors to abuse the :link and :visited pseudo-classes to determine which sites a user has visited without the user's consent.
UAs may therefore treat all links as unvisited links, or implement other measures to preserve the user's privacy while rendering visited and unvisited links differently.
:local-link
The :local-link pseudo-class allows authors to style hyperlinks based on the users current location within a site and to differentiate site-internal versus site-external links.
The (non-functional) :local-link
pseudo-class
represents an element that is the source anchor of a hyperlink whose
target's absolute URL matches the element's own document URL. Any fragment
identifiers are stripped before matching the document's URL against the
link's URL; otherwise all portions of the URL are considered.
For example, the following rule prevents links targetting the current page from being underlined when they are part of the navigation list:
nav :local-link { text-decoration: none; }
As a functional pseudo-class, :local-link()
can also accept
a non-negative integer as its sole argument, which, if the document's URL
belongs to a hierarchical scheme, indicates the number of path levels to
match:
:local-link(0)
’ represents a link element
whose target is in the same domain as the document's URL
:local-link(1)
’ represents a link element
whose target has the same domain and first path segment
:local-link(2)
’ represents a link element
whose target has the same domain, first, and second path segments
The following example styles all site-external links with a dashed underline.
:not(:local-link(0)) { text-decoration-style: dashed; }
Path segments are portions of the URL's path that are separated by forward slashes (/). If a segment is missing from the document's URL, a pseudo-class requiring that segment to match does not match anything. However, an empty final path segment is ignored.
So, given the links:
<a href="http://www.example.com">Home</a>
<a href="http://www.example.com/2011">2011</a>
<a href="http://www.example.com/2011/03">March</a>
<a
href="http://www.example.com/2011/03/">March</a>
<a href="http://www.example.com/2011/03/21">21
March</a>
<a
href="https://www.example.com/2011/03/">March</a>
<a href="http://example.com/2011/03">March</a>
and the styles:
a:local-link {...}
a:local-link(0) {...}
a:local-link(1) {...}
a:local-link(2) {...}
a:local-link(3) {...}
If the document's URL is http://www.example.com/2011/03/
:
The scheme, username, password, port, query string, and fragment
portions of the URL are not considered when matching against
:local-link(n)
. If the document's URL does not
belong to a hierarchical scheme, the functional pseudo-class matches
nothing.
Should a :local-link(2)
match a link from the
document http://example.com/foo
to itself? (This would make
Style 5 apply to Link 4.) (Relatedly, should a link from a document at an
opaque URL to itself also match?)
: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
pointing to an anchor named section_2
in an HTML document:
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.
Example:
p.note:target
This selector represents a p
element of class
note
that is the target element of the referring URL.
CSS example:
Here, the :target
pseudo-class is used to make the target element red and place an image
before it, if there is one:
*:target { color : red } *:target::before { content : url(target.png) }
:scope
The :scope pseudo-class represents any
element that is in the contextual
reference element set. This is is a (potentially empty)
explicitly-specified set of elements, such as that specified by the
querySelector()
call in [SELECTORS-API2], or the
parent element of a scoped
<style>
element in [HTML5], which is used to "scope" a
selector so that it only matches within a subtree.
If no contextual reference element set is given, :scope
is equivalent to :root
. Specifications intending for
this pseudo-class to match specific elements rather than the document's
root element must define a contextual reference element
set.
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.
Examples:
a:link /* unvisited links */ a:visited /* visited links */ a:hover /* user hovers */ a:active /* active links */
An example of combining dynamic pseudo-classes:
a:focus a:focus:hover
The last selector matches a
elements that
are in the pseudo-class :focus and in the pseudo-class :hover.
: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
. For example, [HTML5] defines a
<label>
element as matching
:hover
when its labelled control is hovered.
Note: Since the ‘:hover
’ state can apply
to an element because its child is designated by a pointing device, then
it is possible for ‘:hover
’ to apply to an element that is not
underneath the pointing device.
The :hover
pseudo-class can
apply to any pseudo-element.
: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
’).
: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.
The drag-and-drop pseudo-classes apply while the user is ”dragging“ or otherwise conceptually carrying an item for which the element is a valid drop target.
The :active-drop-target
pseudo-class
represents an element that is the current drop target for an item that is
currently being dragged in a drag-and-drop interface.
The :valid-drop-target
pseudo-class
represents an element that is a possible drop target for an item that is
currently being dragged in a drag-and-drop interface.
The :invalid-drop-target
pseudo-class represents an element that is a possible drop target, but
does not accept the item that is currently being dragged in a
drag-and-drop interface.
For example, [HTML5] defines the dropzone
attribute, which allows an author to declare an element as a "drop
target", and declare what kinds of data the element is willing to accept
from drag-and-drop.
The ‘:valid-drop-target
’ pseudo-class could
be used, for example, to highlight all the valid drop targets for the
item being dragged.
:valid-drop-target { box-shadow: 0 0 5px yellow; }
Meanwhile the ‘:active-drop-target
’
pseudo-class can be used to designate the drop-zone that will receive the
dragged item when dropped.
:active-drop-target { outline: solid red; }
The CSSWG would like to shorten/clarify the names of these
pseudo-classes. Comments are welcome. One possibility would be to simply
drop ‘-target
’ from the current names.
Other suggestions being considered include:
| Set A | Set B | Set C |
|---|---|---|
| :active-drop | :drop | :current-drop |
| :drop | :can-drop | :valid-drop |
| :no-drop | :no-drop | :invalid-drop |
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.
:current
The :current pseudo-class represents the element, or an ancestor of the element, that is currently being displayed.
Its alternate form :current()
, like :matches()
, takes a list of compound selectors as its argument: it
represents the :current
element
that matches the argument or, if that does not match, the innermost
ancestor of the :current
element that does. (If neither the :current
element nor its ancestors
match the argument, then the selector does not represent anything.)
For example, the following rule will highlight whichever paragraph or list item is being read aloud in a speech rendering of the document:
:current(p, li, dt, dd) { background: yellow; }
: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.
: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.
:dir()
The :dir() pseudo-class allows the author to
write selectors that represent an element based on its directionality as
determined by the document language. For example, [HTML5] defines how to
determine the directionality of an element, based on a combination of
the dir
attribute, the surrounding text, and other factors.
The :dir()
pseudo-class does not
select based on stylistic states—for example, the CSS ‘direction
’ property does not affect whether it
matches.
The pseudo-class :dir(ltr)
represents an element that has a
directionality of left-to-right (ltr
). The pseudo-class
:dir(rtl)
represents an element that has a directionality of
right-to-left (rtl
). The argument to :dir()
must be a single identifier,
otherwise the selector is invalid. White space is optionally allowed
between the identifier and the parentheses. Values other than
ltr
and rtl
are not invalid, but do not match
anything. (If a future markup spec defines other directionalities, then
Selectors may be extended to allow corresponding values.)
The difference between :dir(C)
and [dir=C]
is
that [dir=C]
only performs a comparison against a given
attribute on the element, while the :dir(C)
pseudo-class uses
the UAs knowledge of the document's semantics to perform the comparison.
For example, in HTML, the directionality of an element inherits so that a
child without a dir
attribute will have the same
directionality as its closest ancestor with a valid dir
attribute. As another example, in HTML,
an element that matches [dir=auto]
will match
either :dir(ltr)
or :dir(rtl)
depending on the
resolved directionality of the elements as determined by its contents. [HTML5]
: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 combination of the
lang
attribute, information from meta
elements,
and possibly also the protocol (e.g. from HTTP headers). XML languages can
use the xml:lang
attribute to indicate language information
for an element.
The element's language matches a language range if the element's language (normalized to BCP 47 syntax if necessary) matches the given language range in an extended filtering operation per [RFC4647] Matching of Language Tags (section 3.3.2). The matching is performed case-insensitively within the ASCII range. The language range does not need to be a valid language code to perform this comparison.
Note: It is recommended that documents and
protocols indicate language using codes from BCP 47 [BCP47] or its successor, and by means
of xml:lang
attributes in the case of XML-based documents [XML10]. See "FAQ:
Two-letter or three-letter language codes."
Examples:
The two following selectors represent an HTML document that is in
Belgian French or German. The two next selectors represent q
quotations in an arbitrary element in Belgian French or German.
html:lang(fr-be) html:lang(de) :lang(fr-be) > q :lang(de) > q
One difference between :lang(C)
and the ‘|=
’ operator is that the ‘|=
’ operator only performs a comparison against a given
attribute on the element, while the :lang(C)
pseudo-class
uses the UAs knowledge of the document's semantics to perform the
comparison.
In this HTML example, only the BODY matches [lang|=fr]
(because it has a LANG attribute) but both the BODY and the P match
:lang(fr)
(because both are in French). The P does not match
the [lang|=fr]
because it does not have a LANG attribute.
<body lang=fr> <p>Je suis français.</p> </body>
Another difference between :lang(C)
and the ‘|=
’ operator is that :lang(C)
performs
implicit wildcard matching. For example, :lang(de-DE)
will
match all of ‘de-DE
’, ‘de-DE-1996
’, ‘de-Latn-DE
’,
‘de-Latf-DE
’, ‘de-Latn-DE-1996
’, whereas of those
[lang|=de-DE]
will only match ‘de-DE
’ and ‘de-DE-1996
’.
To perform wildcard matching on the first subtag (the primary
language), an asterisk must be used: *-CH
will match all of
‘de-CH
’, ‘it-CH
’,
‘fr-CH
’, and ‘rm-CH
’.
Note that asterisks are not allowed anywhere else in :lang()
‘s language
range syntax: they only have meaning, and are therefore only allowed, at
the beginning.
Wildcard language matching is new in Level 4.
The pseudo-classes in this section mostly apply to elements that take
user input, such as HTML’s <input>
element.
:enabled
and :disabled
pseudo-classesThe :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.
: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.
For example, in [HTML5] a non-disabled
non-readonly <input>
element is
:read-write
, as is any element with the
contenteditable
attribute set to the true state.
:placeholder-shown
Input elements can sometimes show placeholder text as a hint to the user
on what to type in. See, for example, the placeholder
attribute in [HTML5].
The :placeholder-shown pseudo-class
matches an input element that is showing such placeholder text.
:default
The :default pseudo-class applies to the one or more UI elements that are the default among a set of similar elements. Typically applies to context menu items, buttons and select lists/menus.
One example is the default submit button among a set of buttons. Another
example is the default option from a popup menu. In a select-many group
(such as for pizza toppings), multiple elements can match :default
. For example, [HTML5] defines that :default
matches the “default button” in a form, the initially-selected
<option>
(s) in a <select>
, and a few other
elements.
:checked
Radio and checkbox elements can be toggled by the user. Some menu items
are "checked" when the user selects them. When such elements are toggled
"on" the :checked pseudo-class applies. For
example, [HTML5]
defines that checked
checkboxes, radio buttons, and selected <option>
elements
match :checked
.
While the :checked
pseudo-class is dynamic in nature, and can altered by user action, since
it can also be based on the presence of semantic attributes in the
document (such as the selected
and checked
attributes in [HTML5]), it applies to
all media.
An unchecked checkbox can be selected by using the negation pseudo-class:
:not(:checked)
: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.
: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 that there is a difference between an element which has
no constraints, and thus would always be :valid
, and one which has no data
validity semantics at all, and thus is neither :valid
nor :invalid
. In HTML, for example, an
<input type="text">
element may have no constraints, but a
<p>
element has no validity semantics at all, and so it
never matches either of these pseudo-classes.
: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".
: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.
: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.
For example, the input in the following document fragment would match
:invalid
as soon as the page
is loaded (because it the initial value violates the max-constraint), but
it won't match :user-error
until the user significantly interacts with the element, or attempts to
submit the form it's part of.
<form> <label> Volume: <input name='vol' type=number min=0 max=10 value=11> </label> ... </form>
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.
:root
pseudo-classThe :root pseudo-class represents an element
that is the root of the document. In HTML 4, this is always the
HTML
element.
:empty
pseudo-classThe :empty pseudo-class represents an element that has no children at all. In terms of the document tree, only element nodes and content nodes (such as DOM [DOM-LEVEL-3-CORE] text nodes, CDATA nodes, and entity references) whose data has a non-zero length must be considered as affecting emptiness; comments, processing instructions, and other nodes must not affect whether an element is considered empty or not.
Examples:
p:empty
is a valid representation of the following
fragment:
<p></p>
foo:empty
is not a valid representation for the following
fragments:
<foo>bar</foo>
<foo><bar>bla</bar></foo>
<foo>this is not <bar>:empty</bar></foo>
:blank
pseudo-classThe :blank pseudo-class is identical to the
:empty
pseudo-class, except that
it additionally excludes characters
affected by whitespace processing [CSS3TEXT] when determining
whether an element is empty.
For example, the following element matches :blank
, but not :empty
, because it contains at
least one linebreak, and possibly other whitespace:
<p>
</p>
Several pseudo-classes in this section use a micro-syntax to indicate indexes in a list of sibling elements. This syntax is referred to as the An+B notation, and represents an integer step (A) and offset (B). It indicates the An+Bth elements in a list, for every positive integer or zero value of n, with the first element in the list having index 1 (not 0).
For values of A and B greater than 0, this effectively divides the list into groups of A elements (the last group taking the remainder), and selecting the Bth element of each group.
The An+B notation also accepts the
‘even
’ and ‘odd
’
keywords, which have the same meaning as ‘2n
’
and ‘2n+1
’, respectively.
Examples:
2n+0 /* represents all of the even elements in the list */ even /* same */ 4n+1 /* represents the 1st, 5th, 9th, 13th, etc. elements in the list */
The values of A and B can be negative, but only the positive results of An+B, for n ≥ 0, are used.
Example:
-n+6 /* represents the first 6 elements of the list */
If both A and B are 0, the pseudo-class represents no element in the list.
When A is 0, the An part may be
omitted (unless the B part is already
omitted). When An is not included and B is non-negative, the ‘+
’ sign before B (when
allowed) may also be omitted. In this case the syntax simplifies to just
B.
Examples:
0n+5 /* represents the 5th element in the list */ 5 /* same */
When A is 1 or -1, the 1
may be
omitted from the rule.
Examples:
The following notations are therefore equivalent:
1n+0 /* represents all elements in the list */ n+0 /* same */ n /* same */
If B is 0, then every Ath element is picked. In such a case, the +B (or -B) part may be omitted unless the A part is already omitted.
Examples:
2n+0 /* represents every even element in the list */ 2n /* same */
Whitespace is permitted on either side of the ‘+
’ or ‘-
’ that separates the
An and B parts when both are
present.
Valid Examples with white space:
3n + 1 +3n - 2 -n+ 6 +6
Invalid Examples with white space:
3 n + 2n + 2
An informative definition of the An+B syntax is:
/* Tokens */ INTEGER = [0-9]+ N = n|\\0{0,4}(4e|6e)(\r\n|[ \t\r\n\f])?|\\n ODD = a CSS ident with value "odd" EVEN = a CSS ident with value "even" SIGN = '-' | '+' WS = [ \t\r\n\f]+ /* Several of these definitions are taken from the CSS 2.1 Lexical Scanner */ /* Grammar */ nth : WS* [ SIGN? INTEGER? N [ WS* SIGN WS* INTEGER ]? | SIGN? INTEGER | ODD | EVEN ] WS* ;
If an "n" token is provided (the first clause in the grammar), the first integer gives the value of the step. The second integer, if provided, gives the value of the offset, defaulting to 0 if not provided.
If an "n" token is not provided (the second clause in the grammar), the integer gives the offset, and the step defaults to 1.
If "odd" is provided, the step is 2 and the offset is 1. If "even" is provided, the step is 2 and the offset is 0.
The pseudo-classes defined in this section select elements based on their index in their list of siblings.
:nth-child()
pseudo-classThe :nth-child(An+B) pseudo-class notation represents an element that has An+B-1 siblings before it in the document tree. See the An+B section for the definition of its argument.
For example, this selector could address every other row in a table, and could be used to alternate the color of paragraph text in a cycle of four.
Examples:
:nth-child(10n-1) /* represents the 9th, 19th, 29th, etc, element */ :nth-child(10n+9) /* Same */ :nth-child(10n+-1) /* Syntactically invalid, and would be ignored */
:nth-last-child()
pseudo-classThe :nth-last-child(An+B) pseudo-class notation represents an element that has An+B-1 siblings after it in the document tree. See the An+B section for the definition of its argument.
Examples:
tr:nth-last-child(-n+2) /* represents the two last rows of an HTML table */ foo:nth-last-child(odd) /* represents all odd foo elements in their parent element, counting from the last one */
:first-child
pseudo-classThe :first-child pseudo-class
represents an element that precedes all of its siblings (if any). Same as
‘:nth-child(1)
’.
Examples:
The following selector represents a p
element that is the
first child of a div
element:
div > p:first-child
This selector can represent the p
inside the
div
of the following fragment:
<p> The last P before the note.</p> <div class="note"> <p> The first P inside the note.</p> </div>but cannot represent the second
p
in the following fragment:
<p> The last P before the note.</p> <div class="note"> <h2> Note </h2> <p> The first P inside the note.</p> </div>
The following two selectors are usually equivalent:
* > a:first-child /* a is first child of any element */ a:first-child /* Same (assuming a is not the root element) */
:last-child
pseudo-classThe :last-child pseudo-class represents
an element that follows all of its siblings (if any). Same as ‘:nth-last-child(1)
’.
Example:
The following selector represents a list item li
that is
the last child of an ordered list ol
.
ol > li:last-child
:only-child
pseudo-classThe :only-child pseudo-class represents
an element that has no siblings. Same as ‘:first-child:last-child
’ or ‘:nth-child(1):nth-last-child(1)
’, but with a lower
specificity.
The pseudo-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.
:nth-of-type()
pseudo-classThe :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. See the An+B section for the definition of its argument.
CSS example:
This allows an author to alternate the position of floated images:
img:nth-of-type(2n+1) { float: right; } img:nth-of-type(2n) { float: left; }
:nth-last-of-type()
pseudo-classThe :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. See the An+B section for the definition of its argument.
Example:
To represent all h2
children of an XHTML body
except the first and last, one could use the following selector:
body > h2:nth-of-type(n+2):nth-last-of-type(n+2)
In this case, one could also use :not()
, although the selector
ends up being just as long:
body > h2:not(:first-of-type):not(:last-of-type)
:first-of-type
pseudo-classThe :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)
’.
Example:
The following selector represents a definition title dt
inside a definition list dl
, this dt
being the
first of its type in the list of children of its parent element.
dl dt:first-of-type
It is a valid description for the first two dt
elements in
the following example but not for the third one:
<dl> <dt>gigogne</dt> <dd> <dl> <dt>fusée</dt> <dd>multistage rocket</dd> <dt>table</dt> <dd>nest of tables</dd> </dl> </dd> </dl>
:last-of-type
pseudo-classThe :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)
’.
Example:
The following selector represents the last data cell td
of
a table row tr
.
tr > td:last-of-type
:only-of-type
pseudo-classThe :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.
The pseudo-classes in this section are also similar to Child Index Pseudo-classes, but they resolve based on an element's index in the set of siblings that match a given selector.
A selector like ‘p.foo:nth-child(even)
’ means "of all the even siblings,
select the <p>
elements that have the class
foo
", because simple selectors match independently, rather
than the sometimes-desired interpretation of "among the
<p>
elements with class foo
, select the even
ones". The ‘:nth-match()
’ and ‘:nth-last-match()
’ pseudo-classes allow one to
build a selector for the latter interpretation.
In the fast Selectors profile, only lists of compound selectors are allowed within these selectors. In the complete profile, full complex selectors are allowed.
:nth-match()
pseudo-classThe :nth-match(An+B of <selector>) pseudo-class notation represents an element that has An+B-1 siblings that match the given selector list before it in the document tree. See the An+B section for the definition of its first argument.
:nth-last-match()
pseudo-classThe :nth-last-match(An+B of <selector>) pseudo-class notation represents an element that has An+B-1 siblings that match the given selector list after it in the document tree. See the An+B section for the definition of its argument.
At times, authors may want selectors to describe an element that is the
descendant of another element in the document tree (e.g., "an
EM
element that is contained within an H1
element"). Descendant combinators express such a relationship. A descendant combinator is whitespace that separates two compound selectors. A selector of the form
"A B
" represents an element B
that is an arbitrary descendant of some ancestor element A
.
Examples:
For example, consider the following selector:
h1 em
It represents an em
element being the descendant of an
h1
element. It is a correct and valid, but partial,
description of the following fragment:
<h1>This <span class="myclass">headline is <em>very</em> important</span></h1>
The following selector:
div * p
represents a p
element that is a grandchild or later
descendant of a div
element. Note the whitespace on either
side of the "*" is not part of the universal selector; the whitespace is
a combinator indicating that the div
must be the ancestor of
some element, and that that element must be an ancestor of the
p
.
The following selector, which combines descendant combinators and attribute selectors, represents an
element that (1) has the href
attribute set and (2) is
inside a p
that is itself inside a div
:
div p *[href]
A child combinator describes a childhood
relationship between two elements. A child combinator is made of the
"greater-than sign" (U+003E, >
) character and
separates two compound selectors.
Examples:
The following selector represents a p
element that is
child of body
:
body > p
The following example combines descendant combinators and child combinators.
div ol>li p
It represents a p
element that is a descendant of an
li
element; the li
element must be the child of
an ol
element; the ol
element must be a
descendant of a div
. Notice that the optional white space
around the ">" combinator has been left out.
For information on selecting the first child of an element, please see
the section on the :first-child
pseudo-class above.
The next-sibling combinator is
made of the "plus sign" (U+002B, +
) character that
separates two compound selectors. The
elements represented by the two compound
selectors share the same parent in the document tree and the
element represented by the first compound
selector immediately precedes the element represented by the
second one. Non-element nodes (e.g. text between elements) are ignored
when considering the adjacency of elements.
Examples:
The following selector represents a p
element immediately
following a math
element:
math + p
The following selector is conceptually similar to the one in the
previous example, except that it adds an attribute selector — it adds a
constraint to the h1
element, that it must have
class="opener"
:
h1.opener + h2
The following-sibling
combinator is made of the "tilde" (U+007E, ~
)
character that separates two compound
selectors. The elements represented by the two compound selectors share the same parent in
the document tree and the element represented by the first compound
selector precedes (not necessarily immediately) the element represented by
the second one.
Example:
h1 ~ pre
represents a pre
element following an h1
. It
is a correct and valid, but partial, description of:
<h1>Definition of the function a</h1> <p>Function a(x) has to be applied to all figures in the table.</p> <pre>function a(x) = 12x/13.5</pre>
The reference combinator consists of
two slashes with an intervening CSS qualified
name, and separates two compound
selectors, e.g. A /attr/ B
. The element represented
by the first compound selector explicitly
references the element represented by the second compound selector. Unless the host language
defines a different syntax for expressing this relationship, this
relationship is considered to exist if the value of the specified
attribute on the first element is an IDREF or an ID selector referencing the second element.
Attribute matching for reference combinators follow the same rules as for
attribute
selectors.
The following example highlights an <input>
element
when its <label>
is focused or hovered-over:
label:matches(:hover, :focus) /for/ input, /* association by "for" attribute */ label:matches(:hover, :focus):not([for]) input { /* association by containment */ box-shadow: yellow 0 0 10px; }
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.
The column combinator, which consists
of two pipes (‘||
’) represents the relationship
of a column element to a cell element belonging to the column it
represents. Column membership is determined based on the semantics of the
document language only: whether and how the elements are presented is not
considered. If a cell element belongs to more than one column, it is
represented by a selector indicating membership in any of those columns.
The following example makes cells C, E, and G yellow.
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>
:nth-column()
pseudo-classThe :nth-column(An+B) pseudo-class
notation represents a cell element belonging to a column that has An+B-1 columns before it, for
any positive integer or zero value of n
. Column membership is
determined based on the semantics of the document language only: whether
and how the elements are presented is not considered. If a cell element
belongs to more than one column, it is represented by a selector
indicating any of those columns.
See :nth-child()
pseudo-class for the syntax of its argument. It also accepts the ‘
’ and ‘even
’ values as arguments.
odd
:nth-last-column()
pseudo-classThe :nth-last-column(An+B)
pseudo-class notation represents a cell element belonging to a column that
has An+B-1 columns after
it, for any positive integer or zero value of n
. Column
membership is determined based on the semantics of the document language
only: whether and how the elements are presented is not considered. If a
cell element belongs to more than one column, it is represented by a
selector indicating any of those columns.
See :nth-child()
pseudo-class for the syntax of its argument. It also accepts the ‘
’ and ‘even
’ values as arguments.
odd
A selector's specificity is calculated as follows:
The specificity of a :matches() pseudo-class is
the specificity of the most specific complex selector that matched. (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.
Examples:
* /* a=0 b=0 c=0 */ LI /* a=0 b=0 c=1 */ UL LI /* a=0 b=0 c=2 */ UL OL+LI /* a=0 b=0 c=3 */ H1 + *[REL=up] /* a=0 b=1 c=1 */ UL OL LI.red /* a=0 b=1 c=3 */ LI.red.level /* a=0 b=2 c=1 */ #x34y /* a=1 b=0 c=0 */ #s12:not(FOO) /* a=1 b=0 c=1 */
Note: Repeated occurrances of the same simple selector are allowed and do increase specificity.
Note: The specificity of the styles
specified in an HTML style
attribute is described in CSS
Style Attributes. [CSSSTYLEATTR]
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:
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. The production "S" represents a whitespace token. The wqname_prefix production comes from the Namespaces spec [CSS3NAMESPACE] The
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:
complex_selector_list
production representing a selector list.
scope_relative_selector_list
production representing a
selector list comprised of scope-relative selectors.
compound_selector_list
production representing a selector list comprised of compound selectors.
id
production representing an ID selector
Significant changes since the 23 August 2012 Working Draft include:
:blank
and :placeholder-shown
pseudo-classes.
:matches()
and :not()
.
:matches()
.
:local-link()
pseudo-class now ignores trailing
slashes.
Conformance requirements are expressed with a combination of descriptive assertions and RFC 2119 terminology. The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this document are to be interpreted as described in RFC 2119. However, for readability, these words do not appear in all uppercase letters in this specification.
All of the text of this specification is normative except sections explicitly marked as non-normative, examples, and notes. [RFC2119]
Examples in this specification are introduced with the words “for
example” or are set apart from the normative text with
class="example"
, like this:
This is an example of an informative example.
Informative notes begin with the word “Note” and are set apart from
the normative text with class="note"
, like this:
Note, this is an informative note.
Conformance to Selectors Level 4 is defined for three conformance classes:
A selector instance is conformant to Selectors Level 4 if it is valid according to the selector syntax rules defined in this specification.
An interpreter is conformant to Selectors Level 4 if it parses interprets selectors according to the semantics defined in Selectors Level 4 (including following the error-handling rules). However, the inability of a user agent to implement part of this specification due to the limitations of a particular device (e.g., non interactive user agents will probably not implement dynamic pseudo-classes because they make no sense without interactivity) does not imply non-conformance.
An authoring tool is conformant to Selectors Level 4 if it writes syntactically correct selectors.
Any specification reusing Selectors must define which subset of Selectors it accepts or excludes, and describe any constraints it adds to the current specification.
Specifications reusing Selectors must define how to handle invalid selectors. (In the case of CSS, the entire rule in which the selector is used is effectively dropped.)
So that authors can exploit the forward-compatible parsing rules to trigger fallback behavior, UAs must treat as invalid any selectors for which they have no usable level of support.
To avoid clashes with future Selectors features, the Selectors specification reserves a prefixed syntax for proprietary extensions to Selectors. The CSS Working Group recommends that experimental implementations of features in Selectors Working Drafts also use vendor-prefixed pseudo-element or pseudo-class names. This avoids any incompatibilities with future changes in the draft. Once a specification reaches the Candidate Recommendation stage, implementors should implement the non-prefixed syntax for any feature they consider to be correctly implemented according to spec.
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


Riverbank is a Delta Sharing server implemented in Rust. The Delta Sharing Protocol is still very early on and so this project may see significant changes.


Phase 0 End Reflection
A blog about blogging
March 19, 2016
It has been a great experience building a personal website during phase-0. One of the frustrations I have had in my career has been the inability to be able to point to something tangible at the end of a project which very often only ended in a report that was shelved away and forgotten. It therefore feels great to be able to share a link with friends and family and show them what I have been up to these past 8 weeks.
It was sometimes challenging to overcome the fear of writing about a topic in a blog that I had only just learned myself, and that I knew I my knowledge was barely scratching the surface. Nevertheless, this process was tremendously helpful in solidifying what I had learned, especially since we were asked to put down our reflections in newbie terms.
As part of the final touch-up of phase-0, I went through my index pages, blog pages, and contact page correcting the little formatting and mismatched layout items that had always been bugging me but that I was never able to get around to before. I am happy with where the website stands at the end of phase-0 and look forward to receiving and incorporating feedback going forward.
Thanks to all my pairs, guides,
and especially Andrew Larson
for a fantastic phase-1 journey.
This is Afaan signing off....


Wellness Program
A month long educational measurable program for elderly person to create awareness about health risks and how to manage them.


We extend tables!
- transition back-end e-services
- harness turn-key communities
- envisioneer clicks-and-mortar users
- embrace B2C convergence
- utilize world-class applications
- aggregate robust mindshare
- innovate value-added infomediaries
- synthesize mission-critical supply-chains
- iterate interactive models
- utilize strategic supply-chains


If you see someone scamming in the community, contact me using the social media links on the home page.


The Popover directive can be used to show extra content when required. This content can be a string of text or your own custom template and it supports multiple placements.
In our Plunker example we have created a popover which appears when hovering the email addresses. This popover shows more detail
about the sender and recipients and contains a nested popover which the user can view by clicking the
button.
There are 2 versions of the popover which you can implement:
popover
- takes a string of text only and will escape any HTML provided.popover-template
- takes a string variable which specifies the location of a template to be used for the popover
body.The Popover directive also provides some optional attributes to configure how it will be displayed:
top
, bottom
, left
and right
.
mouseenter
- popover will display while the element is hovered.click
- popover will display when the element is clicked and will hide when the element is clicked
again.focus
- popover will display when the element is focused and will hide when the element is blurred.outsideClick
- same as click
only clicking anywhere outside of the directive element
or popover will hide the popover.insideHover
- same asmouseenter
only the popover will not disappear while the directive
element or popover are hovered.popover-trigger="insideHover"
is used.
Note: If you wish to implement a nested popover inside a popover which has set
popover-trigger="insideHover"
then you must ensure the nested popover has setpopover-append-to-body="false"
otherwise both popovers will disappear when hovering the nested popover.
You can see the code used in our example by selecting the appropriate tabs below:


Home
Theatres
Movie Experiences
Food and Drinks
Book Tickets
Choose Your Theatre
Brampton Cinemas
North York Cinemas
Mississauga Cinemas
Markham Cinemas
All Movies


Contract Control Panel
Request Fund
REQUEST FUND
×
Which phase do you want the fund for?
PHASE 1
PHASE 2
PHASE 3
Description:
Amount:


NAKED unveil second EP, Killed By Roses, in Halcyon Veil trilogy
The duo's next release on Rabit's label is out on January 24th.
by Marissa CetinUp next on Halcyon Veil is an EP from NAKED called Killed By Roses.
Agnes Gryczkowska and Alex Johnston return to Rabit's label for the second part of their trilogy, which started with the 2017 EP Total Power Exchange. The London- and Berlin-based duo aim for "psychological horror drama" with Killed By Roses, according to the label. They're currently collaborating with the London Contemporary Orchestra for the third and final part in the series and a theatrical live show.
Read Andrew Ryce's Label Of The Month feature on Halcyon Veil from earlier this year.
Watch the video for "BITE."
Tracklist
01. BITE
02. TEAR
03. AUTOSADISM
04. BLADE
05. DESTROY
Halcyon Veil will release Killed By Roses on January 24th, 2020.
Art credit: Dennis Schoenberg, Collin Fletcher


Register
First Name
Last name
Email
Password
Repeat Password
I agree to the Terms and Conditions
Login
Email
Password
Register
Login


FilterPro (TM)
BURR-BROWN FILTER DESIGN PROGRAMS
(c) Copyright 1991, 2001 Burr-Brown Corporation, Texas Instruments, Inc.
Contents of this text:
Brief descriptions of two Burr-Brown filter design programs
Supporting Literature
Hardware Requirements
Printer Output
Printing Response Plots
MacIntosh Computers
New Version of FILTER42-- 1.1
BRIEF DESCRIPTIONS--
This disk contains a DOS-compatible program to aid in active filter design and two graphics dump utilities. The programs are not Burr-Brown products, but application information intended to aid in using our components. They are easy to use, with helpful on-screen prompts. Just try them!
FILTER42 designs a wide variety of filters using Burr-Brown's UAF42 Universal Active Filter IC. This state-variable filter provides low-pass, high-pass and band-pass outputs. Notch filters can also be designed.
EGAHPRES and EGAFXRES are screen dump utilities that can print response plots on HP Laserjet and Epson printers, respectively. See "printing response plots."
SUPPORTING LITERATURE--
Filter42 can be used without documentation. You will eventually need the Application Bulletin for circuit details. These are available free from Burr-Brown. You can request the printed bulletins by calling 1-800-548-6132 in the USA or by contacting your local Burr-Brown representative. Or, you can have the bulletins faxed directly to you (USA only) by calling our FaxLine at 1-800-548-6133 (use the special document numbers at the right).
|
Application |
FaxLine |
| |
Program # |
Document # |
| ---------------------- |
---------------------- |
---------------------- |
| Filter42 |
AB-035 |
20036 |
Note: Burr-Brown's 1994 Applications Handbook contains the bulletin on page 349.
Send written requests to:
Applications Engineering
Burr-Brown Corporation
P.O. Box 11400
Tucson, AZ 85734
HARDWARE NOTES
These programs will run on virtually all PC-compatible computers. To
display response plots, you need VGA (or EGA) graphics. If you do not
have a graphics display, you can still use them, but you cannot display
response plots.
On some keyboards, the arrow keys will not work with Caps-lock and/or
Num-lock; turn them off if the arrow keys don't work. Numbers should be
typed on the main keyboard, not the numeric keypad.
PRINTER OUTPUT
Printer output (text only) for both programs works with any 80-column
(or wider) printer. Printer output is directed to LPT1.
PRINTING RESPONSE PLOTS
There is no facility within the programs to print response plots. If
you have a graphics screen-dump utility, try it. We have provided two
simple screen-dump programs for your convenience. EGAHPRES is for HP
Laserjet printers. EGAFXRES is for Epson-compatible printers. Both are
memory-resident programs which work with EGA or VGA graphics displays.
The appropriate program must be loaded prior to running the filter
program by typing its file name. To print a graphics screen press
<Shift-Print-screen> while the desired plot is displayed. If it works,
consider it a bonus from Burr-Brown.
MacIntosh COMPUTERS
FilterPro programs are not available for the MacIntosh. A program
called "SoftPC" from Insignia Solutions Inc emulates a PC in software.
FILTER2 runs using this program, albeit very slow. To display response
plots, you also need Insignia's EGA emulation program. The total cost
of both programs runs hundreds of dollars. Perhaps you have other PC
programs you would like to run on your MAC?
Various add-on hardware is available for MACs to allow running PC
programs. These probably work, but have not been tested. The
equivalent PC must have EGA, or VGA compatible graphics to display
response plots.
REVISION OF FILTER42 PROGRAM
A previous version of FILTER42 (1.0) crashed on some computers. This
has been corrected with version 1.1. There are no other functional
changes in the program. Version 1.1 produces the same filter designs as
version 1.0. Version 1.11 corrects some minor cosmetics in the program,
only.


Computers
Computing labs, open classrooms, and loaner laptops/iPads are available for UCSF students, faculty, and staff. Use your UCSF ID for entry to computing spaces.
Parnassus Library Tech Commons, CL230
Medical Sciences Building, S165
- 24/7 access for UCSF students, faculty, residents and fellows
- PCs, 2 iMacs
-<PHONE_NUMBER>
Mission Bay Library, CC151
- Macs only, UCSF student ID access whenever the Rutter Center is open
- 1675 Owens Street, Rutter Community Center
-<PHONE_NUMBER>
Loaner Laptops
- Check out at Parnassus Service Desk
- Library borrower account required
- For use in the Parnassus Library only
- More info:<PHONE_NUMBER>
Loaner iPads
- Check out at Tech Commons Service Desk, CL240
- Library borrower account required
- 1 week loan period, may be reserved in advance
- More info:<PHONE_NUMBER>