1. Introduction
1.1. Background
This section is not normative.
[CSS21] defines one type of conditional group rule, the
'@media' rule, and allows only style rules (not other @-rules)
inside of it. The '@media' rule provides the ability to
have media-specific style sheets, which is also provided by style
sheet linking features such as '@import' and <link>
. The restrictions on the contents of
'@media' rules made them less useful; they have forced authors
using CSS features involving @-rules in media-specific style sheets to
use separate style sheets for each medium.
This specification extends the rules for the contents of conditional group rules to allow other @-rules, which enables authors to combine CSS features involving @-rules with media specific style sheets within a single style sheet.
This specification also defines an additional type of conditional group rule, '@supports', to address author and user requirements.
The '@supports' rule allows CSS to be conditioned on implementation support for CSS properties and values. This rule makes it much easier for authors to use new CSS features and provide good fallback for implementations that do not support those features. This is particularly important for CSS features that provide new layout mechanisms, and for other cases where a set of related styles needs to be conditioned on property support.
1.2. Module Interactions
This module replaces and extends the '@media' rule feature defined in [CSS21] section 7.2.1 and incorporates the modifications previously made non-normatively by [MEDIAQ] section 1.
Its current definition depends on @-rules defined in [CSS3-FONTS] and [CSS3-ANIMATIONS], but that dependency is only on the assumption that those modules will advance ahead of this one. If this module advances faster, then the dependency will be reversed.
In order to allow these new @-rules in CSS style sheets, this
specification modifies the stylesheet
production in the Appendix G grammar of [CSS21] by replacing the media
production defined in [CSS21] with the media
production defined in this one,
and additionally inserting | supports_rule
alongside ruleset | media | page
.
2. Processing of conditional group rules
This specification defines some CSS @-rules, called conditional group rules, that associate a condition with a group of other CSS rules. These different rules allow testing different types of conditions, but share common behavior for how their contents are used when the condition is true and when the condition is false.
For example, this rule:
@media print { /* hide navigation controls when printing */ #navigation { display: none } }
causes a particular CSS rule (making elements with ID “navigation” be display:none) apply only when the style sheet is used for a print medium.
Each conditional group rule has a condition, which at any time evaluates to true or false. When the condition is true, CSS processors must apply the rules inside the group rule as though they were at the group rule’s location; when the condition is false, CSS processors must not apply any of rules inside the group rule. The current state of the condition does not affect the CSS object model, in which the contents of the group rule always remain within the group rule.
This means that when multiple conditional group rules are nested, a rule inside of both of them applies only when all of the rules' conditions are true.
@media print { // rule (1) /* hide navigation controls when printing */ #navigation { display: none } @media (max-width: 12cm) { // rule (2) /* keep notes in flow when printing to narrow pages */ .note { float: none } } }
the condition of the rule marked (1) is true for print media, and the condition of the rule marked (2) is true when the width of the display area (which for print media is the page box) is less than or equal to 12cm. Thus the rule #navigation { display: none } applies whenever this style sheet is applied to print media, and the rule .note { float: none } is applied only when the style sheet is applied to print media and the width of the page box is less than or equal to 12 centimeters.
When the condition for a conditional group rule changes, CSS processors must reflect that the rules now apply or no longer apply, except for properties whose definitions define effects of computed values that persist past the lifetime of that value (such as for some properties in [CSS3-TRANSITIONS] and [CSS3-ANIMATIONS]).
3. Contents of conditional group rules
The syntax of each conditional group rule consists of some syntax specific to the type of rule followed by a group rule body, which is a block (pair of braces) containing a sequence of rules.
A group rule body is allowed to contain style rules and any @-rules that are allowed at the top level of a style sheet before and after a style rule. This means that @-rules that must occur at the beginning of the style sheet (such as '@charset', '@import', and '@namespace' rules) are not allowed inside of conditional group rules. Conditional group rules can be nested.
In terms of the grammar, this specification defines the following productions for use in the grammar of conditional group rules:
Note: Style rules are defined in grammars
by the ruleset
production.
nested_statement : ruleset | media | page | font_face_rule | keyframes_rule | supports_rule ; group_rule_body : '{' S* nested_statement* '}' S* ;
in which all the productions are defined in that grammar with the
exception of font_face_rule
defined in [CSS3-FONTS], keyframes_rule
defined in [CSS3-ANIMATIONS], and media
and supports_rule
defined in this specification.
In general, future CSS specifications that add new @-rules that are
not forbidden to occur after some other types of rules should modify
this nested_statement
production to keep the grammar
accurate.
Style sheets must not use rules other than the allowed ones inside conditional group rules.
CSS processors must ignore rules that are not allowed within a group rule, and must handle invalid rules inside of group rules as described in section 4.2 (Rules for handling parsing errors), section 4.1.5 (At-rules), and section 4.1.7 (Rule sets, declaration blocks, and selectors) of [CSS21].
4. Placement of conditional group rules
Conditional group rules are allowed at the top-level of a style sheet, and inside other conditional group rules. CSS processors must process such rules as described above.
Any rules that are not allowed after a style rule (e.g., @charset, @import, or @namespace rules) are also not allowed after a conditional group rule. Therefore, style sheets must not place such rules after a conditional group rules, and CSS processors must ignore such rules.
5. Media-specific style sheets: the '@media' rule
The @media rule is a conditional group rule whose condition is a media query. It consists of the at-keyword '@media' followed by a (possibly empty) media query list (as defined in [MEDIAQ]), followed by a group rule body. The condition of the rule is the result of the media query.
This '@media' rule:
@media screen and (min-width: 35em), print and (min-width: 40em) { #section_navigation { float: left; width: 10em; } }
has the condition screen and (min-width: 35em), print and (min-width: 40em), which is true for screen displays whose viewport is at least 35 times the initial font size and for print displays whose viewport is at least 40 times the initial font size. When either of these is true, the condition of the rule is true, and the rule #section_navigation { float: left; width: 10em; } is applied.
In terms of the grammar, this specification extends the media
production in the Grammar of CSS 2.1 ([CSS21], Appendix G) into:
media : MEDIA_SYM S* media_query_list group_rule_body ;
where the group_rule_body
production is defined in this
specification, the media_query_list
production is defined
in [MEDIAQ], and the others are defined in the Grammar of CSS 2.1 ([CSS21], Appendix G).
6. Feature queries: the '@supports' rule
The @supports rule is a conditional group rule whose condition tests whether the user agent supports CSS property:value pairs. Authors can use it to write style sheets that use new features when available but degrade gracefully when those features are not supported. CSS has existing mechanisms for graceful degradation, such as ignoring unsupported properties or values, but these are not always sufficient when large groups of styles need to be tied to the support for certain features, as is the case for use of new layout system features.
The syntax of the condition in the '@supports' rule is slightly more complicated than for the other conditional group rules (though has some similarities to media queries) since:
- negation is needed so that the new-feature styles and the fallback styles can be separated (within the forward-compatible grammar’s rules for the syntax of @-rules), and not required to override each other
- conjunction (and) is needed so that multiple required features can be tested
- disjunction (or) is needed when there are multiple alternative features for a set of styles, particularly when some of those alternatives are vendor-prefixed properties or values
Therefore, the syntax of the '@supports' rule allows testing for property:value pairs, and arbitrary conjunctions (and), disjunctions (or), and negations (not) of them.
This extends the lexical scanner in the Grammar of CSS 2.1 ([CSS21], Appendix G) by adding:
@{S}{U}{P}{P}{O}{R}{T}{S} {return SUPPORTS_SYM;} {O}{R} {return OR;}
This then extends the grammar in the Grammar of CSS 2.1,
using the lexical scanner there, with the additions of AND
and NOT
tokens defined in the Media Queries specification [MEDIAQ] and the OR
and SUPPORTS_SYM
tokens defined above,
and with declaration
, any
,
and unused
productions
and the FUNCTION
token
taken from the core syntax of CSS defined in section 4.1.1 (Tokenization) of [CSS21],
by adding:
supports_rule : SUPPORTS_SYM S* supports_condition group_rule_body ; supports_condition : supports_negation | supports_conjunction | supports_disjunction | supports_condition_in_parens ; supports_condition_in_parens : ( '(' S* supports_condition ')' S* ) | supports_declaration_condition | general_enclosed ; supports_negation : NOT S* supports_condition_in_parens ; supports_conjunction : supports_condition_in_parens ( AND S* supports_condition_in_parens )+ ; supports_disjunction : supports_condition_in_parens ( OR S* supports_condition_in_parens )+ ; supports_declaration_condition : '(' S* declaration ')' S* ; general_enclosed : ( FUNCTION | '(' ) ( any | unused )* ')' S* ;
The <supports-condition> production is defined as matching the supports_condition
grammar, defined above.
Implementations must parse @supports rules
based on the above grammar,
and when interpreting the above grammar, must match the production before an |
operator
in preference to the one after it.
The above grammar is purposely very loose for forwards-compatibility reasons,
since the general_enclosed
production
allows for substantial future extensibility.
Any @supports rule that does not parse according to the grammar above
(that is, a rule that does not match this loose grammar
which includes the general_enclosed
production)
is invalid.
Style sheets must not use such a rule and
processors must ignore such a rule (including all of its contents).
Each of these grammar terms is associated with a boolean result, as follows:
- supports_condition
- The result is the result of the single child term.
- supports_condition_in_parens
- The result is the result of the single
supports_condition
orsupports_declaration_condition
child term. - supports_negation
- The result is the negation of the result of the
supports_condition_in_parens
child term. - supports_conjunction
- The result is true if the result of all of the
supports_condition_in_parens
child terms is true; otherwise it is false. - supports_disjunction
- The result is true if the result of any of the
supports_condition_in_parens
child terms is true; otherwise it is false. - supports_declaration_condition
- The result is whether the CSS processor supports the declaration within the parentheses.
- general_enclosed
- The result is always false. Additionally, style sheets must not write @supports rules that match this grammar production. (In other words, this production exists only for future extensibility, and is not part of the description of a valid style sheet in this level of the specification.) Note that future levels may define functions or other parenthesized expressions that can evaluate to true.
The condition of the '@supports' rule is the result of the supports_condition
term that is a child of the supports_rule
term.
For example, the following rule
@supports ( display: flex ) { body, #navigation, #content { display: flex; } #navigation { background: blue; color: white; } #article { background: white; color: black; } }
applies the rules inside the '@supports' rule only when display: flex is supported.
The following example shows an additional '@supports' rule that can be used to provide an alternative for when display: flex is not supported:
@supports not ( display: flex ) { body { width: 100%; height: 100%; background: white; color: black; } #navigation { width: 25%; } #article { width: 75%; } }
Note that the width declarations may be harmful to the flex-based layout, so it is important that they be present only in the non-flex styles.
The following example checks for support for the box-shadow property, including checking for support for vendor-prefixed versions of it. When the support is present, it specifies both box-shadow (with the prefixed versions) and border in a way what would cause the box to become invisible were box-shadow not supported.
.noticebox { border: 1px solid black; padding: 1px; } @supports ( box-shadow: 0 0 2px black inset ) or ( -moz-box-shadow: 0 0 2px black inset ) or ( -webkit-box-shadow: 0 0 2px black inset ) or ( -o-box-shadow: 0 0 2px black inset ) { .noticebox { -moz-box-shadow: 0 0 2px black inset; -webkit-box-shadow: 0 0 2px black inset; -o-box-shadow: 0 0 2px black inset; box-shadow: 0 0 2px black inset; /* unprefixed last */ /* override the rule above the @supports rule */ border: none; padding: 2px; } }
To avoid confusion between and and or, the syntax requires that both and and or be specified explicitly (rather than, say, using commas or spaces for one of them). Likewise, to avoid confusion caused by precedence rules, the syntax does not allow and, or, and not operators to be mixed without a layer of parentheses.
For example, the following rule is not valid:
@supports (transition-property: color) or (animation-name: foo) and (transform: rotate(10deg)) { // ... }
Instead, authors must write one of the following:
@supports ((transition-property: color) or (animation-name: foo)) and (transform: rotate(10deg)) { // ... }
@supports (transition-property: color) or ((animation-name: foo) and (transform: rotate(10deg))) { // ... }
The declaration being tested must always occur within parentheses, when it is the only thing in the expression.
For example, the following rule is not valid:
@supports display: flex { // ... }
Instead, authors must write:
@supports (display: flex) { // ... }
The syntax allows extra parentheses when they are not needed. This flexibility is sometimes useful for authors (for example, when commenting out parts of an expression) and may also be useful for authoring tools.
A trailing !important on a declaration being tested is allowed, though it won’t change the validity of the declaration.
6.1. Definition of support
For forward-compatibility, section 4.1.8 (Declarations and properties) of [CSS21] defines rules for handling invalid properties and values. CSS processors that do not implement or partially implement a specification must treat any part of a value that they do not implement, or do not have a usable level of support for, as invalid according to this rule for handling invalid properties and values, and therefore must discard the declaration as a parse error.
A CSS processor is considered to support a declaration (consisting of a property and value) if it accepts that declaration (rather than discarding it as a parse error). If a processor does not implement, with a usable level of support, the value given, then it must not accept the declaration or claim support for it.
Note that properties or values whose support is effectively disabled by user preferences are still considered as supported by this definition. For example, if a user has enabled a high-contrast mode that causes colors to be overridden, the CSS processor is still considered to support the color property even though declarations of the color property may have no effect. On the other hand, a developer-facing preference whose purpose is to enable or disable support for an experimental CSS feature does affect this definition of support.
These rules (and the equivalence between them) allow authors to use fallback (either in the [CSS1] sense of declarations that are overridden by later declarations or with the new capabilities provided by the @supports rule in this specification) that works correctly for the features implemented. This applies especially to compound values; implementations must implement all parts of the value in order to consider the declaration supported, either inside a style rule or in the declaration condition of an @supports rule.
7. APIs
7.1. Extensions to the CSSRule
interface
The CSSRule
interface is extended as follows:
partial interface CSSRule { const unsigned short SUPPORTS_RULE = 12; };
7.2. The CSSGroupingRule
interface
The CSSGroupingRule
interface represents an at-rule that contains other rules nested inside itself.
interface CSSGroupingRule : CSSRule { readonly attribute CSSRuleList cssRules; unsigned long insertRule (DOMString rule, unsigned long index); void deleteRule (unsigned long index); };
cssRules
of typeCSSRuleList
, readonly- The
cssRules
attribute must return aCSSRuleList
object for the list of CSS rules nested inside the grouping rule.
insertRule(DOMString rule, unsigned long index)
, returnsunsigned long
-
The
insertRule
operation must insert a CSS rule rule into the CSS rule list returned bycssRules
, such that the inserted rule will be at position index, and any rules previously at index or higher will increase their index by one. It must throw INDEX_SIZE_ERR if index is greater thancssRules.length
. It must throw SYNTAX_ERR if rule has a syntax error and is unparseable; this does not include syntax errors handled by error handling rules for constructs inside of the rule, but this does include cases where the string given does not parse into a single CSS rule (such as when the string is empty) or where there is anything other than whitespace or comments after that single CSS rule. It must throw HIERARCHY_REQUEST_ERR if the rule cannot be inserted at the location specified, for example, if an @import rule is inserted inside a group rule.The return value is the index parameter.
deleteRule (unsigned long index)
, returnvoid
- The
deleteRule
operation must remove a CSS rule from the CSS rule list returned bycssRules
at index. It must throw INDEX_SIZE_ERR if index is greater than or equal tocssRules.length
.
7.3. The CSSConditionRule
interface
The CSSConditionRule
interface represents
all the “conditional” at-rules,
which consist of a condition and a statement block.
interface CSSConditionRule : CSSGroupingRule { attribute DOMString conditionText; };
conditionText
of typeDOMString
-
The
conditionText
attribute represents the condition of the rule. Since what this condition does varies between the derived interfaces ofCSSConditionRule
, those derived interfaces may specify different behavior for this attribute (see, for example,CSSMediaRule
below). In the absence of such rule-specific behavior, the following rules apply:The
conditionText
attribute, on getting, must return the result of serializing the associated condition.On setting the
conditionText
attribute these steps must be run:- Trim the given value of white space.
- If the given value matches the grammar of the appropriate condition production for the given rule, replace the associated CSS condition with the given value.
- Otherwise, do nothing.
7.4. The CSSMediaRule
interface
The CSSMediaRule
interface represents a @media rule:
interface CSSMediaRule : CSSConditionRule { readonly attribute MediaList media; };
media
of typeMediaList
, readonly- The
media
attribute must return aMediaList
object for the list of media queries specified with the @media rule. conditionText
of typeDOMString
(CSSMediaRule-specific definition for attribute on CSSConditionRule)-
The
conditionText
attribute (defined on theCSSConditionRule
parent rule), on getting, must return the value ofmedia.mediaText
on the rule.Setting the
conditionText
attribute must set themedia.mediaText
attribute on the rule.
7.5. The CSSSupportsRule
interface
The CSSSupportsRule
interface represents a @supports rule.
interface CSSSupportsRule : CSSConditionRule {
};
conditionText
of typeDOMString
(CSSSupportsRule-specific definition for attribute on CSSConditionRule)- The
conditionText
attribute (defined on theCSSConditionRule
parent rule), on getting, must return the condition that was specified, without any logical simplifications, so that the returned condition will evaluate to the same result as the specified condition in any conformant implementation of this specification (including implementations that implement future extensions allowed by the general_enclosed exensibility mechanism in this specification). In other words, token stream simplifications are allowed (such as reducing whitespace to a single space or omitting it in cases where it is known to be optional), but logical simplifications (such as removal of unneeded parentheses, or simplification based on evaluating results) are not allowed.
7.6. The CSS
interface, and the supports()
function
The CSS
interface holds useful CSS-related functions that do not belong elsewhere.
partial interface CSS { static boolean supports(DOMString property, DOMString value); static boolean supports(DOMString conditionText); };
supports(DOMString property, DOMString value)
, returnsboolean
supports(DOMString conditionText)
, returnsboolean
-
When the
supports()
method is invoked with two arguments property and value, it must returntrue
if property is a literal match for the name of a CSS property that the UA supports, and value would be successfully parsed as a supported value for that property. (Literal match means that no CSS escape processing is performed, and leading and trailing whitespace are not stripped, so any leading whitespace, trailing whitespace, or CSS escapes equivalent to the name of a property would cause the method to returnfalse
.) Otherwise, it must returnfalse
.When invoked with a single conditionText argument, it must return
true
if conditionText, when either parsed and evaluated as asupports_condition
or parsed as adeclaration
, wrapped in implied parentheses, and evaluated as asupports_condition
, would return true. Otherwise, it must returnfalse
.
8. Changes
The following (non-editorial) changes were made to this specification since the 4 April 2013 Candidate Recommendation:
- Drop requirement for spaces around and, or, and not keywords for consistency with Media Queries (which are themselves constrained by compatibility with the output of some CSS minimizers that rely on some of the more arcane aspects of CSS tokenization). Note that white space--or a comment--is still required after these keywords, since without it they and the ensuing opening parenthesis will be tokenized as a function opening token.
- Allow the
supports()
method to imply parentheses for simple declarations, for consistency with the @import rule’s supports() function. - Fixed missing semicolons in IDL code.
- Updated links, terminology, and example code in response to changes to other modules.
Acknowledgments
Thanks to the ideas and feedback from Tab Atkins, Arthur Barstow, Ben Callahan, Tantek Çelik, Alex Danilo, Elika Etemad, Pascal Germroth, Björn Höhrmann, Paul Irish, Brad Kemper, Anne van Kesteren, Vitor Menezes, Alex Mogilevsky, Chris Moschini, James Nurthen, Simon Pieters, Florian Rivoal, Simon Sapin, Nicholas Shanks, Ben Ward, Zack Weinberg, Estelle Weyl, Boris Zbarsky, and all the rest of the www-style community.
Privacy and Security Considerations
This spec introduces no new security considerations.
While this spec does modify the definition of the @media rule, which does have some privacy considerations, the modifications defined here do not have any effect on the privacy considerations for @media. No other feature in this spec has any privacy considerations.