# CSS Typed OM Level 1

## Editor’s Draft, 1 January 1970

This version:
  https://drafts.css-houdini.org/css-typed-om-1/
Latest published version:
  https://www.w3.org/TR/css-typed-om-1/
Previous Versions:
  https://www.w3.org/TR/2018/WD-css-typed-om-1-20180410/
  https://www.w3.org/TR/2017/WD-css-typed-om-1-20170801/
  https://www.w3.org/TR/2016/WD-css-typed-om-1-20160607/
Feedback:
  public-houdini@w3.org with subject line “`[css-typed-om] … message topic …`” (archives)
Editors:
  Tab Atkins-Bittner (Google)
  François Remy (Microsoft)
Former Editors:
  Shane Stephens
  Naina Raisinghani (Google)
Issue Tracking:
  GitHub Issues

Copyright © 1970 W3C® (MIT, ERCIM, Keio, Beihang). W3C liability, trademark and document use rules apply.

## Abstract

Converting CSSOM value strings into meaningfully typed JavaScript representations and back can incur a significant performance overhead. This specification exposes CSS values as typed JavaScript objects to facilitate their performant manipulation.

## Status of this document

This is a public copy of the editors’ draft. It is provided for discussion only and may change at any moment. Its publication here does not imply endorsement of its contents by W3C. Don’t cite this document other than as work in progress.

GitHub Issues are preferred for discussion of this specification. When filing an issue, please put the text “css-typed-om” in the title, preferably like this: “[css-typed-om] …summary of comment…”. All issues and comments are archived.

This document was produced by the CSS Working Group.

This document was produced by a group operating under the 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 document is governed by the 1 March 2019 W3C Process Document.

## 1. Introduction

CSS stylesheets are parsed into abstract UA-internal data structures, the internal representations of CSS, which various specification algorithms manipulate.

Internal representations can’t be directly manipulated, as they are implementation-dependent; UAs have to agree on how to interpret the internal representations, but the representations themselves are purposely left undefined so that UAs can store and manipulate CSS in whatever way is most efficient for them.

Previously, the only way to read or write to the internal representations was via strings—stylesheets or the CSSOM allowed authors to send strings to the UA, which were parsed into internal representations, and the CSSOM allowed authors to request that the UA serialize their internal representations back into strings.

This specification introduces a new way to interact with internal representations, by representing them with specialized JS objects that can be manipulated and understood more easily and more reliably than string parsing/concatenation. This new approach is both easier for authors (for example, numeric values are reflected with actual JS numbers, and have unit-aware mathematical operations defined for them) and in many cases are more performant, as values can be directly manipulated and then cheaply translated back into internal representations without having to build and then parse strings of CSS.

## 2. `CSSStyleValue` objects

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSStyleValue {
        stringifier;
        [Exposed=Window] static CSSStyleValue parse(USVString property, USVString cssText);
        [Exposed=Window] static sequence<CSSStyleValue> parseAll(USVString property, USVString cssText);
    };

`CSSStyleValue` objects are the base class of all CSS values accessible via the Typed OM API.

The stringification behavior of `CSSStyleValue` objects is defined in § 6 CSSStyleValue Serialization.

The `parse(property, cssText)` method, when invoked, must parse a CSSStyleValue with property property, cssText cssText, and parseMultiple set to false, and return the result.

The `parseAll(property, cssText)` method, when invoked, must parse a CSSStyleValue with property property, cssText cssText, and parseMultiple set to true, and return the result.

To parse a CSSStyleValue given a string property, a string cssText, and a parseMultiple flag, run these steps:

1. If property is not a custom property name string, set property to property ASCII lowercased.

2. If property is not a valid CSS property, throw a `TypeError`.

3. Attempt to parse cssText according to property’s grammar. If this fails, throw a `TypeError`. Otherwise, let whole value be the parsed result.

   The behavior of custom properties are different when modified via JavaScript than when defined in style sheets.

   When a custom property is defined with an invalid syntax in a style sheet, then the value is recorded as "unset", to avoid having to reparse every style sheet when a custom property is registered.

   Conversely, when a custom property is modified via the JavaScript API, any parse errors are propagated to the progamming environment via a `TypeError`. This allows more immediate feedback of errors to developers.

4. Subdivide into iterations whole value, according to property, and let values be the result.

5. For each value in values, replace it with the result of reifying value for property.

   Define the global.

6. If parseMultiple is false, return values[0]. Otherwise, return values.

To subdivide into iterations a CSS value whole value for a property property, execute the following steps:

1. If property is a single-valued property, return a list containing whole value.

2. Otherwise, divide whole value into individual iterations, as appropriate for property, and return a list containing the iterations in order.

How to divide a list-valued property into iterations is intentionally undefined and hand-wavey at the moment. Generally, you just split it on top-level commas (corresponding to a top-level `<foo>#` term in the grammar), but some legacy properties (such as counter-reset) don’t separate their iterations with commas.

It’s expected to be rigorously defined in the future, but at the moment is explicitly a "you know what we mean" thing.

### 2.1. Direct `CSSStyleValue` Objects

Values that can’t yet be directly supported by a more specialized `CSSStyleValue` subclass are instead represented as `CSSStyleValue` objects.

Each `CSSStyleValue` object is associated with a particular CSS property, via its `[[associatedProperty]]` internal slot, and a particular, immutable, internal representation. These objects are said to "represent" the particular internal representation they were reified from, such that if they are set back into a stylesheet for the same property, they reproduce an equivalent internal representation.

These `CSSStyleValue` objects are only considered valid for the property that they were parsed for. This is enforced by `CSSStyleValue` objects having a `[[associatedProperty]]` internal slot, which is either `null` (the default) or a string specifying a property name.

Note: This slot is checked by `StylePropertyMap`.`set()`/`append()`

## 3. The `StylePropertyMap`

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface StylePropertyMapReadOnly {
        iterable<USVString, sequence<CSSStyleValue>>;
        any get(USVString property);
        /* 'any' means (undefined or CSSStyleValue) here,
           see https://github.com/heycam/webidl/issues/60 */
        sequence<CSSStyleValue> getAll(USVString property);
        boolean has(USVString property);
        readonly attribute unsigned long size;
    };

    [Exposed=Window]
    interface StylePropertyMap : StylePropertyMapReadOnly {
        void set(USVString property, (CSSStyleValue or USVString)... values);
        void append(USVString property, (CSSStyleValue or USVString)... values);
        void delete(USVString property);
        void clear();
    };

`StylePropertyMap` is an alternate way to represent a CSS declaration block as an object (when fetched via the [cssom], CSS declaration blocks are instead represented as `CSSStyleDeclaration` objects.)

A `StylePropertyMapReadOnly` object has a `[[declarations]]` internal slot, which is a map reflecting the CSS declaration block's declarations.

Note: The declarations are not yet defined using [infra] terminology, but for the purpose of this spec it’s assumed to be a map whose keys are strings (representing property names) and whose values are internal representations for those properties.

Unless otherwise stated, the initial ordering of the `[[declarations]]` internal slot is based on the key of each entry:

1. Standardized properties (not custom properties or vendor-prefixed properties), ASCII lowercased and then sorted in increasing code-point order.

2. Vendor-prefixed/experimental properties (those whose name starts with a single dash), ASCII lowercased and then sorted in increasing code-point order.

3. Custom properties, sorted in increasing code-point order. (These are never lower-cased; they are preserved exactly as written.)

The value pairs to iterate over for a `StylePropertyMapReadOnly` object this are obtained as follows:

1. Let declarations be this’s `[[declarations]]` slot.

2. Let value pairs be an empty list.

3. For each prop → value in declarations:

   1. Let iterations be the result of dividing into iterations value.

   2. Reify each item of iterations, and let objects be the result.

   3. Append prop/objects to value pairs.

4. Return value pairs.

Some CSS properties are list-valued properties, such as background-image or animation; their value is a list of parallel grammar terms, almost always comma-separated (the only exceptions are certain legacy properties like counter-reset), indicating multiple distinct "values" interpreted in the same way. Other properties, such as color, are single-valued properties; they take only a single (possibly complex) value.

Define precisely which properties are list-valued and which aren’t, probably in an appendix. <https://github.com/w3c/css-houdini-drafts/issues/644>

There are multiple examples of CSS properties that have transitioned from being single-valued to list-valued. To ensure that code written at a time when a property was single-valued does not break when it becomes list-valued in the future, the `StylePropertyMap` is a multi-map; it stores list of values for each key, but allows you to interact with it as if there was only a single value for each key as well.

This means that multiple values for a single property in a `StylePropertyMap` do not represent multiple successive definition of that property’s value; instead, they represent multiple comma-separated sub-values in a single property value, like each "layer" in a background-image property.

The `get(property)` method, when called on a `StylePropertyMap` this, must perform the following steps:

1. If property is not a custom property name string, set property to property ASCII lowercased.

2. If property is not a valid CSS property, throw a `TypeError`.

3. Let props be the value of this’s `[[declarations]]` internal slot.

4. If props[property] exists, subdivide into iterations props[property], then reify the first item of the result and return it.

   Otherwise, return `undefined`.

   Define the global.

The `getAll(property)` method, when called on a `StylePropertyMap` this, must perform the following steps:

1. If property is not a custom property name string, set property to property ASCII lowercased.

2. If property is not a valid CSS property, throw a `TypeError`.

3. Let props be the value of this’s `[[declarations]]` internal slot.

4. If props[property] exists, subdivide into iterations props[property], then reify each item of the result, and return the list.

   Otherwise, return an empty list.

   Define the global.

The `has(property)` method, when called on a `StylePropertyMap` this, must perform the following steps:

1. If property is not a custom property name string, set property to property ASCII lowercased.

2. If property is not a valid CSS property, throw a `TypeError`.

3. Let props be the value of this’s `[[declarations]]` internal slot.

4. If props[property] exists, return `true`. Otherwise, return `false`.

The `size` attribute, on getting from a `StylePropertyMap` this, must perform the following steps:

1. Return the size of the value of this’s `[[declarations]]` internal slot.

The `set(property, ...values)` method, when called on a `StylePropertyMap` this, must perform the following steps:

1. If property is not a custom property name string, set property to property ASCII lowercased.

2. If property is not a valid CSS property, throw a `TypeError`.

3. If property is a single-valued property and values has more than one item, throw a `TypeError`.

4. If any of the items in values have a non-null `[[associatedProperty]]` internal slot, and that slot’s value is anything other than property, throw a `TypeError`.

5. If the size of values is two or more, and one or more of the items are a `CSSUnparsedValue` or `CSSVariableReferenceValue` object, throw a `TypeError`.

   Note: Having 2+ values implies that you’re setting multiple items of a list-valued property, but the presence of a var() function in the string-based OM disables all syntax parsing, including splitting into individual iterations (because there might be more commas inside of the var() value, so you can’t tell how many items are actually going to show up). This step’s restriction preserves the same semantics in the Typed OM.

6. Let props be the value of this’s `[[declarations]]` internal slot.

7. If props[property] exists, remove it.

8. Let values to set be an empty list.

9. For each value in values, create an internal representation for property and value, and append the result to values to set.

10. Set props[property] to values to set.

Note: The property is deleted then added back so that it gets put at the end of the ordered map, which gives the expected behavior in the face of shorthand properties.

The `append(property, ...values)` method, when called on a `StylePropertyMap` this, must perform the following steps:

1. If property is not a custom property name string, set property to property ASCII lowercased.

2. If property is not a valid CSS property, throw a `TypeError`.

3. If property is not a list-valued property, throw a `TypeError`.

4. If any of the items in values have a non-null `[[associatedProperty]]` internal slot, and that slot’s value is anything other than property, throw a `TypeError`.

5. If any of the items in values are a `CSSUnparsedValue` or `CSSVariableReferenceValue` object, throw a `TypeError`.

   Note: When a property is set via string-based APIs, the presence of var() in a property prevents the entire thing from being interpreted. In other words, everything besides the var() is a plain component value, not a meaningful type. This step’s restriction preserves the same semantics in the Typed OM.

6. Let props be the value of this’s `[[declarations]]` internal slot.

7. If props[property] does not exist, set props[property] to an empty list.

8. If props[property] contains a var() reference, throw a `TypeError`.

9. Let temp values be an empty list.

10. For each value in values, create an internal representation with property and value, and append the returned value to temp values.

11. Append the entries of temp values to props[property].

The `delete(property)` method, when called on a `StylePropertyMap` this, must perform the following steps:

1. If property is not a custom property name string, set property to property ASCII lowercased.

2. If property is not a valid CSS property, throw a `TypeError`.

3. If this’s `[[declarations]]` internal slot contains property, remove it.

The `clear()` method, when called on a `StylePropertyMap` this, must perform the following steps:

1. Remove all of the declarations in this’s `[[declarations]]` internal slot.

To create an internal representation, given a string property and a string or `CSSStyleValue` value:

If value is a direct `CSSStyleValue`,

  Return value’s associated value.

If value is a `CSSStyleValue` subclass,

  If value does not match the grammar of a list-valued property iteration of property, throw a `TypeError`.

  If any component of property’s CSS grammar has a limited numeric range, and the corresponding part of value is a `CSSUnitValue` that is outside of that range, replace that value with the result of wrapping it in a fresh `CSSMathSum` whose `values` internal slot contains only that part of value.

  Return the value.

If value is a `USVString`,

  Parse a CSSStyleValue with property property, cssText value, and parseMultiple set to `false`, and return the result.

  Note: This can throw a `TypeError` instead.

CSS properties express their valid inputs with grammars, which are written with the assumption of being matched against strings parsed into CSS tokens, as defined in CSS Syntax 3 §4 Tokenization. `CSSStyleValue` objects can also be matched against these grammars, however.

A `CSSStyleValue` is said to match a grammar based on the following rules:

- A `CSSKeywordValue` matches an ident specified in a grammar if its `value` internal slot matches the ident.

  If case-folding rules are in effect normally for that ident (such as Auto matching the keyword auto specified in the grammar for width), they apply to this comparison as well.

- A `CSSTransformValue` matches <transform-list>.

- A `CSSNumericValue` matches what its type matches.

- A `CSSURLImageValue` matches <url>.

- Any subclass of `CSSImageValue` matches <image>.

- A `CSSUnparsedValue` matches any grammar.

- A direct `CSSStyleValue` object (not a subclass) with a non-null `[[associatedProperty]]` slot matches the grammar of the property specified in its `[[associatedProperty]]` slot, regardless of what it is.

Note: As the ability to create more complex values in Typed OM increases, this section will become more complex.

A string is a custom property name string if it starts with two dashes (U+002D HYPHEN-MINUS), like `--foo`. (This corresponds to the <custom-property-name> production, but applies to strings, rather than identifiers; it can be used without invoking the CSS parser.)

A string is a valid CSS property if it is a custom property name string, or is a CSS property name recognized by the user agent.

### 3.1. Computed `StylePropertyMapReadOnly` objects

    partial interface Element {
        [SameObject] StylePropertyMapReadOnly computedStyleMap();
    };

Computed StylePropertyMap objects represent the computed values of an `Element`, and are accessed by calling the `computedStyleMap()` method.

Every `Element` has a `[[computedStyleMapCache]]` internal slot, initially set to `null`, which caches the result of the `computedStyleMap()` method when it is first called.

The `computedStyleMap()` method must, when called on an `Element` this, perform the following steps:

1. If this’s `[[computedStyleMapCache]]` internal slot is set to `null`, set its value to a new `StylePropertyMapReadOnly` object, whose `[[declarations]]` internal slot are the name and computed value of every longhand CSS property supported by the User Agent, every registered custom property, and every non-registered custom property which is not set to its initial value on this, in the standard order.

   The computed values in the `[[declarations]]` of this object must remain up-to-date, changing as style resolution changes the properties on this and how they’re computed.

   Note: In practice, since the values are "hidden" behind a `.get()` method call, UAs can delay computing anything until a given property is actually requested.

2. Return this’s `[[computedStyleMapCache]]` internal slot.

Note: like `Window.getComputedStyle()`, this method can expose information from stylesheets with the origin-clean flag unset.

Note: The `StylePropertyMapReadOnly` returned by this method represents the actual computed values, not the resolved value concept used by `Window.getComputedStyle()`. It can thus return different values than `Window.getComputedStyle()` for some properties (such as width).

Note: Per WG resolution, pseudo-element styles are intended to be obtainable by adding this method to the new `PseudoElement` interface (rather than using a `pseudoElt` argument like `Window.getComputedStyle()` does).

### 3.2. Declared & Inline `StylePropertyMap` objects

    partial interface CSSStyleRule {
        [SameObject] readonly attribute StylePropertyMap styleMap;
    };

    partial interface mixin ElementCSSInlineStyle {
        [SameObject] readonly attribute StylePropertyMap attributeStyleMap;
    };

Declared StylePropertyMap objects represent style property-value pairs embedded in a style rule or inline style, and are accessed via the `styleMap` attribute of `CSSStyleRule` objects, or the `attributeStyleMap` attribute of objects implementing the `ElementCSSInlineStyle` interface mixin (such as `HTMLElement`s).

When constructed, the `[[declarations]]` internal slot for declared StylePropertyMap objects is initialized to contain an entry for each property with a valid value inside the `CSSStyleRule` or inline style that the object represents, in the same order as the `CSSStyleRule` or inline style.

## 4. `CSSStyleValue` subclasses

### 4.1. `CSSUnparsedValue` objects

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(sequence<CSSUnparsedSegment> members)]
    interface CSSUnparsedValue : CSSStyleValue {
        iterable<CSSUnparsedSegment>;
        readonly attribute unsigned long length;
        getter CSSUnparsedSegment (unsigned long index);
        setter CSSUnparsedSegment (unsigned long index, CSSUnparsedSegment val);
    };

    typedef (USVString or CSSVariableReferenceValue) CSSUnparsedSegment;

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(USVString variable, optional CSSUnparsedValue? fallback = null)]
    interface CSSVariableReferenceValue {
        attribute USVString variable;
        readonly attribute CSSUnparsedValue? fallback;
    };

`CSSUnparsedValue` objects represent property values that reference custom properties. They are comprised of a list of string fragments and variable references.

They have a `[[tokens]]` internal slot, which is a list of `USVString`s and `CSSVariableReferenceValue` objects. This list is the object’s values to iterate over.

The `length` attribute returns the size of the `[[tokens]]` internal slot.

The supported property indexes of a `CSSUnparsedValue` this are the integers greater than or equal to 0, and less than the size of this’s `[[tokens]]` internal slot.

To determine the value of an indexed property of a `CSSUnparsedValue` this and an index n, let tokens be this’s `[[tokens]]` internal slot, and return tokens[n].

To set the value of an existing indexed property of a `CSSUnparsedValue` this, an index n, and a value new value, let tokens be this’s `[[tokens]]` internal slot, and set tokens[n] to new value.

To set the value of a new indexed property of a `CSSUnparsedValue` this, an index n, and a value new value, let tokens be this’s `[[tokens]]` internal slot. If n is not equal to the size of tokens, throw a `RangeError`. Otherwise, append new value to tokens.

The getter for the `variable` attribute of a `CSSVariableReferenceValue` this must return its `variable` internal slot.

The `variable` attribute of a `CSSVariableReferenceValue` this must, on setting a variable variable, perform the following steps:

1. If variable is not a custom property name string, throw a `TypeError`.

2. Otherwise, set this’s `variable` internal slot to variable.

The `CSSVariableReferenceValue(variable, fallback)` constructor must, when called, perform the following steps:

1. If variable is not a custom property name string, throw a `TypeError`.

2. Return a new `CSSVariableReferenceValue` with its `variable` internal slot set to variable and its `fallback` internal slot set to fallback.

### 4.2. `CSSKeywordValue` objects

`CSSKeywordValue` objects represent CSS keywords and other identifiers.

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(USVString value)]
    interface CSSKeywordValue : CSSStyleValue {
        attribute USVString value;
    };

The `CSSKeywordValue(value)` constructor must, when called, perform the following steps:

1. If value is an empty string, throw a `TypeError`.

2. Otherwise, return a new `CSSKeywordValue` with its `value` internal slot set to value.

Any place that accepts a `CSSKeywordValue` also accepts a raw `USVString`, by using the following typedef and algorithm:

    typedef (DOMString or CSSKeywordValue) CSSKeywordish;

To rectify a keywordish value val, perform the following steps:

1. If val is a `CSSKeywordValue`, return val.

2. If val is a `DOMString`, return a new `CSSKeywordValue` with its `value` internal slot set to val.

The `value` attribute of a `CSSKeywordValue` this must, on setting a value value, perform the following steps:

1. If value is an empty string, throw a `TypeError`.

2. Otherwise, set this’s `value` internal slot, to value.

### 4.3. Numeric Values:

`CSSNumericValue` objects represent CSS values that are numeric in nature (<number>s, <percentage>s, <dimension>s). There are two interfaces that inherit from `CSSNumericValue`:

- `CSSUnitValue` objects represent values that contain a single unit type (for example "42px").

- `CSSMathValue` objects represent math expressions, which can contain more than one value/unit (for example "calc(56em + 10%)").

`CSSNumericValue` objects are not range-restricted. Any valid numeric value can be represented by a `CSSNumericValue`, and that value will not be clamped, rounded, or rejected when set on a declared StylePropertyMap. Instead, clamping and/or rounding will occur during computation of style.

The following code is valid

    myElement.attributeStyleMap.set("opacity", CSS.number(3));
    myElement.attributeStyleMap.set("z-index", CSS.number(15.4));

    console.log(myElement.attributeStyleMap.get("opacity").value); // 3
    console.log(myElement.attributeStyleMap.get("z-index").value); // 15.4

    var computedStyle = myElement.computedStyleMap();
    var opacity = computedStyle.get("opacity");
    var zIndex = computedStyle.get("z-index");

After execution, the value of `opacity` is `1` (opacity is range-restricted), and the value of `zIndex` is `15` (z-index is rounded to an integer value).

Note: "Numeric values" which incorporate variable references will instead be represented as `CSSUnparsedValue` objects, and keywords as `CSSKeywordValue` objects.

Any place that accepts a `CSSNumericValue` also accepts a raw `double`, by using the following typedef and algorithm:

    typedef (double or CSSNumericValue) CSSNumberish;

To rectify a numberish value num, perform the following steps:

1. If num is a `CSSNumericValue`, return num.

2. If num is a `double`, return a new `CSSUnitValue` with its `value` internal slot set to num and its `unit` internal slot set to "number".

#### 4.3.1. Common Numeric Operations, and the `CSSNumericValue` Superclass

All numeric CSS values (<number>s, <percentage>s, and <dimension>s) are represented by subclasses of the `CSSNumericValue` interface.

    enum CSSNumericBaseType {
        "length",
        "angle",
        "time",
        "frequency",
        "resolution",
        "flex",
        "percent",
    };

    dictionary CSSNumericType {
        long length;
        long angle;
        long time;
        long frequency;
        long resolution;
        long flex;
        long percent;
        CSSNumericBaseType percentHint;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSNumericValue : CSSStyleValue {
        CSSNumericValue add(CSSNumberish... values);
        CSSNumericValue sub(CSSNumberish... values);
        CSSNumericValue mul(CSSNumberish... values);
        CSSNumericValue div(CSSNumberish... values);
        CSSNumericValue min(CSSNumberish... values);
        CSSNumericValue max(CSSNumberish... values);

        boolean equals(CSSNumberish... value);

        CSSUnitValue to(USVString unit);
        CSSMathSum toSum(USVString... units);
        CSSNumericType type();

        [Exposed=Window] static CSSNumericValue parse(USVString cssText);
    };

The methods on the `CSSNumericValue` superclass represent operations that all numeric values can perform.

The following are the arithmetic operations you can perform on dimensions:

The `add(...values)` method, when called on a `CSSNumericValue` this, must perform the following steps:

1. Replace each item of values with the result of rectifying a numberish value for the item.

2. If this is a `CSSMathSum` object, prepend the items in this’s `values` internal slot to values. Otherwise, prepend this to values.

3. If all of the items in values are `CSSUnitValue`s and have the same `unit`, return a new `CSSUnitValue` whose `unit` internal slot is set to this’s `unit` internal slot, and `value` internal slot is set to the sum of the `value` internal slots of the items in values. This addition must be done "left to right" - if values is « 1, 2, 3, 4 », the result must be (((1 + 2) + 3) + 4). (This detail is necessary to ensure interoperability in the presence of floating-point arithmetic.)

4. Let type be the result of adding the types of every item in values. If type is failure, throw a `TypeError`.

5. Return a new `CSSMathSum` object whose `values` internal slot is set to values.

The `sub(...values)` method, when called on a `CSSNumericValue` this, must perform the following steps:

1. Replace each item of values with the result of rectifying a numberish value for the item, then negating the value.

2. Return the result of calling the `add()` internal algorithm with this and values.

To negate a `CSSNumericValue` this:

1. If this is a `CSSMathNegate` object, return this’s `value` internal slot.

2. If this is a `CSSUnitValue` object, return a new `CSSUnitValue` with the same `unit` internal slot as this, and a `value` internal slot set to the negation of this’s.

3. Otherwise, return a new `CSSMathNegate` object whose `value` internal slot is set to this.

The `mul(...values)` method, when called on a `CSSNumericValue` this, must perform the following steps:

1. Replace each item of values with the result of rectifying a numberish value for the item.

2. If this is a `CSSMathProduct` object, prepend the items in this’s `values` internal slot to values. Otherwise, prepend this to values.

3. If all of the items in values are `CSSUnitValue`s with `unit` internal slot set to "number", return a new `CSSUnitValue` whose `unit` internal slot is set to "number", and `value` internal slot is set to the product of the `value` internal slots of the items in values.

   This multiplication must be done "left to right" - if values is « 1, 2, 3, 4 », the result must be (((1 × 2) × 3) × 4). (This detail is necessary to ensure interoperability in the presence of floating-point arithmetic.)

4. If all of the items in values are `CSSUnitValue`s with `unit` internal slot set to "number" except one which is set to unit, return a new `CSSUnitValue` whose `unit` internal slot is set to unit, and `value` internal slot is set to the product of the `value` internal slots of the items in values.

   This multiplication must be done "left to right" - if values is « 1, 2, 3, 4 », the result must be (((1 × 2) × 3) × 4).

5. Let type be the result of multiplying the types of every item in values. If type is failure, throw a `TypeError`.

6. Return a new `CSSMathProduct` object whose `values` internal slot is set to values.

The `div(...values)` method, when called on a `CSSNumericValue` this, must perform the following steps:

1. Replace each item of values with the result of rectifying a numberish value for the item, then inverting the value.

2. Return the result of calling the `mul()` internal algorithm with this and values.

To invert a `CSSNumericValue` this:

1. If this is a `CSSMathInvert` object, return this’s `value` internal slot.

2. If this is a `CSSUnitValue` object with `unit` internal slot set to "number":

   1. If this’s `value` internal slot is set to 0 or -0, throw a `RangeError`.

   2. Else return a new `CSSUnitValue` with the `unit` internal slot set to "number", and a `value` internal slot set to 1 divided by this’s {CSSUnitValue/value}} internal slot.

3. Otherwise, return a new `CSSMathInvert` object whose `value` internal slot is set to this.

The `min(...values)` method, when called on a `CSSNumericValue` this, must perform the following steps:

1. Replace each item of values with the result of rectifying a numberish value for the item.

2. If this is a `CSSMathMin` object, prepend the items in this’s `values` internal slot to values. Otherwise, prepend this to values.

3. If all of the items in values are `CSSUnitValue`s and have the same `unit`, return a new `CSSUnitValue` whose `unit` internal slot is set to this’s `unit` internal slot, and `value` internal slot is set to the minimum of the `value` internal slots of the items in values.

4. Let type be the result of adding the types of every item in values. If type is failure, throw a `TypeError`.

5. Return a new `CSSMathMin` object whose `values` internal slot is set to values.

The `max(...values)` method, when called on a `CSSNumericValue` this, must perform the following steps:

1. Replace each item of values with the result of rectifying a numberish value for the item.

2. If this is a `CSSMathMax` object, prepend the items in this’s `values` internal slot to values. Otherwise, prepend this to values.

3. If all of the items in values are `CSSUnitValue`s and have the same `unit`, return a new `CSSUnitValue` whose `unit` internal slot is set to this’s `unit` internal slot, and `value` internal slot is set to the maximum of the `value` internal slots of the items in values.

4. Let type be the result of adding the types of every item in values. If type is failure, throw a `TypeError`.

5. Return a new `CSSMathMax` object whose `values` internal slot is set to values.

The `equals(...values)` method, when called on a `CSSNumericValue` this, must perform the following steps:

1. Replace each item of values with the result of rectifying a numberish value for the item.

2. For each item in values, if the item is not an equal numeric value to this, return `false`.

3. Return `true`.

This notion of equality is purposely fairly exacting; all the values must be the exact same type and value, in the same order. For example, `CSSMathSum(CSS.px(1), CSS.px(2))` is not equal to `CSSMathSum(CSS.px(2), CSS.px(1))`.

This precise notion is used because it allows structural equality to be tested for very quickly; if we were to use a slower and more forgiving notion of equality, such as allowing the arguments to match in any order, we’d probably want to go all the way and perform other simplifications, like considering 96px to be equal to 1in; this looser notion of equality might be added in the future.

To determine whether two `CSSNumericValue`s value1 and value2 are equal numeric values, perform the following steps:

1. If value1 and value2 are not members of the same interface, return `false`.

2. If value1 and value2 are both `CSSUnitValue`s, return `true` if they have equal `unit` and `value` internal slots, or `false` otherwise.

3. If value1 and value2 are both `CSSMathSum`s, `CSSMathProduct`s, `CSSMathMin`s, or `CSSMathMax`s:

   1. If value1’s `values` and value2s `values` internal slots have different sizes, return `false`.

   2. If any item in value1’s `values` internal slot is not an equal numeric value to the item in value2’s `values` internal slot at the same index, return `false`.

   3. Return `true`.

4. Assert: value1 and value2 are both `CSSMathNegate`s or `CSSMathInvert`s.

5. Return whether value1’s `value` and value2’s `value` are equal numeric values.

The `to(unit)` method converts an existing `CSSNumericValue` this into another one with the specified unit, if possible. When called, it must perform the following steps:

1. Let type be the result of creating a type from unit. If type is failure, throw a `SyntaxError`.

2. Let sum be the result of creating a sum value from this. If sum is failure, throw a `TypeError`.

3. If sum has more than one item, throw a `TypeError`. Otherwise, let item be the result of creating a CSSUnitValue from the sole item in sum, then converting it to unit. If item is failure, throw a `TypeError`.

4. Return item.

When asked to create a CSSUnitValue from a sum value item item, perform the following steps:

1. If item has more than one entry in its unit map, return failure.

2. If item has no entries in its unit map, return a new `CSSUnitValue` whose `unit` internal slot is set to "number", and whose `value` internal slot is set to item’s value.

3. Otherwise, item has a single entry in its unit map. If that entry’s value is anything other than `1`, return failure.

4. Otherwise, return a new `CSSUnitValue` whose `unit` internal slot is set to that entry’s key, and whose `value` internal slot is set to item’s value.

The `toSum(...units)` method converts an existing `CSSNumericValue` this into a `CSSMathSum` of only `CSSUnitValue`s with the specified units, if possible. (It’s like `to()`, but allows the result to have multiple units in it.) If called without any units, it just simplifies this into a minimal sum of `CSSUnitValue`s.

When called, it must perform the following steps:

1. For each unit in units, if the result of creating a type from unit is failure, throw a `SyntaxError`.

2. Let sum be the result of creating a sum value from this. If sum is failure, throw a `TypeError`.

3. Let values be the result of creating a CSSUnitValue for each item in sum. If any item of values is failure, throw a `TypeError`.

4. If units is empty, sort values in code point order according to the `unit` internal slot of its items, then return a new `CSSMathSum` object whose `values` internal slot is set to values.

5. Otherwise, let result initially be an empty list. For each unit in units:

   1. Let temp initially be a new `CSSUnitValue` whose `unit` internal slot is set to unit and whose `value` internal slot is set to `0`.

   2. For each value in values:

      1. Let value unit be value’s `unit` internal slot.

      2. If value unit is a compatible unit with unit, then:

         1. Convert value to unit.

         2. Increment temp’s `value` internal slot by the value of value’s `value` internal slot.

         3. Remove value from values.

   3. Append temp to result.

6. If values is not empty, throw a `TypeError`. this had units that you didn’t ask for.

7. Return a new `CSSMathSum` object whose `values` internal slot is set to result.

The `type()` method returns a representation of the type of this.

When called, it must perform the following steps:

1. Let result be a new `CSSNumericType`.

2. For each baseType → power in the type of this,

   1. If power is not 0, set result[baseType] to power.

3. If the percent hint of this is not null,

   1. Set `percentHint` to the percent hint of this.

4. Return result.

A sum value is an abstract representation of a `CSSNumericValue` as a sum of numbers with (possibly complex) units. Not all `CSSNumericValue`s can be expressed as a sum value.

A sum value is a list. Each entry in the list is a tuple of a value, which is a number, and a unit map, which is a map of units (strings) to powers (integers).

Here are a few examples of CSS values, and their equivalent sum values:

- 1px becomes `«(1, «["px" → 1]»)»`

- calc(1px + 1in) becomes `«(97, «["px" → 1]»)»` (because in and px are compatible units, and px is the canonical unit for them)

- calc(1px + 2em) becomes `«(1, «["px" → 1]»), (2, «["em" → 1]»)»`

- calc(1px + 2%) becomes `«(1, «["px" → 1]»), (2, «["percent" → 1]»)»` (percentages are allowed to add to other units, but aren’t resolved into another unit, like they are in a type)

- calc(1px * 2em) becomes `«(2, «["em" → 1, "px" → 1]»)»`

- calc(1px + 1deg) can’t be represented as a sum value because it’s an invalid computation

- calc(1px * 2deg) becomes `«(2, «["deg" → 1, "px" → 1]»)»`

To create a sum value from a `CSSNumericValue` this, the steps differ based on this’s class:

`CSSUnitValue`

  1. Let unit be the value of this’s `unit` internal slot, and value be the value of this’s `value` internal slot.

  2. If unit is a member of a set of compatible units, and is not the set’s canonical unit, multiply value by the conversion ratio between unit and the canonical unit, and change unit to the canonical unit.

  3. If unit is `"number"`, return «(value, «[ ]»)».

  4. Otherwise, return `«(value, «[unit → 1]»)»`.

`CSSMathSum`

  1. Let values initially be an empty list.

  2. For each item in this’s `values` internal slot:

     1. Let value be the result of creating a sum value from item. If value is failure, return failure.

     2. For each subvalue of value:

        1. If values already contains an item with the same unit map as subvalue, increment that item’s value by the value of subvalue.

        2. Otherwise, append subvalue to values.

  3. Create a type from the unit map of each item of values, and add all the types together. If the result is failure, return failure.

  4. Return values.

`CSSMathNegate`

  1. Let values be the result of creating a sum value from this’s `value` internal slot.

  2. If values is failure, return failure.

  3. Negate the value of each item of values.

  4. Return values.

`CSSMathProduct`

  1. Let values initially be the sum value «(1, «[ ]»)». (I.e. what you’d get from 1.)

  2. For each item in this’s `values` internal slot:

     1. Let new values be the result of creating a sum value from item. Let temp initially be an empty list.

     2. If new values is failure, return failure.

     3. For each item1 in values:

        1. For each item2 in new values:

           1. Let item be a tuple with its value set to the product of the values of item1 and item2, and its unit map set to the product of the unit maps of item1 and item2, with all entries with a zero value removed.

           2. Append item to temp.

     4. Set values to temp.

  3. Return values.

`CSSMathInvert`

  1. Let values be the result of creating a sum value from this’s `value` internal slot.

  2. If values is failure, return failure.

  3. If the length of values is more than one, return failure.

  4. Invert (find the reciprocal of) the value of the item in values, and negate the value of each entry in its unit map.

  5. Return values.

`CSSMathMin`

  1. Let args be the result of creating a sum value for each item in this’s `values` internal slot.

  2. If any item of args is failure, or has a length greater than one, return failure.

  3. If not all of the unit maps among the items of args are identical, return failure.

  4. Return the item of args whose sole item has the smallest value.

`CSSMathMax`

  1. Let args be the result of creating a sum value for each item in this’s `values` internal slot.

  2. If any item of args is failure, or has a length greater than one, return failure.

  3. If not all of the unit maps among the items of args are identical, return failure.

  4. Return the item of args whose sole item has the largest value.

To create a type from a unit map unit map:

1. Let types be an initially empty list.

2. For each unit → power in unit map:

   1. Let type be the result of creating a type from unit.

   2. Set type’s sole value to power.

   3. Append type to types.

3. Return the result of multiplying all the items of types.

The product of two unit maps units1 and units2 is the result given by the following steps:

1. Let result be a copy of units1.

2. For each unit → power in units2:

   1. If result[unit] exists, increment result[unit] by power.

   2. Otherwise, set result[unit] to power.

3. Return result.

The `parse()` method allows a `CSSNumericValue` to be constructed directly from a string containing CSS. Note that this is a static method, existing directly on the `CSSNumericValue` interface object, rather than on `CSSNumericValue` instances.

The `parse(cssText)` method, when called, must perform the following steps:

1. Parse a component value from cssText and let result be the result. If result is a syntax error, throw a `SyntaxError` and abort this algorithm.

2. If result is not a <number-token>, <percentage-token>, <dimension-token>, or a math function, throw a `SyntaxError` and abort this algorithm.

3. Reify a numeric value result, and return the result.

#### 4.3.2. Numeric Value Typing

Each `CSSNumericValue` has an associated type, which is a map of base types to integers, and an associated percent hint. The base types are "length", "angle", "time", "frequency", "resolution", "flex", and "percent". The ordering of a type’s entries always matches this base type ordering. The percent hint is either null or a base type other than "percent".

Note: As new unit types are added to CSS, they’ll be added to this list of base types, and to the CSS math functions.

To create a type from a string unit, follow the appropriate branch of the following:

unit is "number"

  Return «[ ]» (empty map)

unit is "percent"

  Return «[ "percent" → 1 ]»

unit is a <length> unit

  Return «[ "length" → 1 ]»

unit is an <angle> unit

  Return «[ "angle" → 1 ]»

unit is a <time> unit

  Return «[ "time" → 1 ]»

unit is a <frequency> unit

  Return «[ "frequency" → 1 ]»

unit is a <resolution> unit

  Return «[ "resolution" → 1 ]»

unit is a <flex> unit

  Return «[ "flex" → 1 ]»

anything else

  Return failure.

In all cases, the associated percent hint is null.

To add two types type1 and type2, perform the following steps:

1. Replace type1 with a fresh copy of type1, and type2 with a fresh copy of type2. Let finalType be a new type with an initially empty ordered map and an initially null percent hint.

2. If both type1 and type2 have non-null percent hints with different values

     The types can’t be added. Return failure.

   If type1 has a non-null percent hint hint and type2 doesn’t

     Apply the percent hint hint to type2.

     Vice versa if type2 has a non-null percent hint and type1 doesn’t.

   Otherwise

     Continue to the next step.

3. If all the entries of type1 with non-zero values are contained in type2 with the same value, and vice-versa

     Copy all of type1’s entries to finalType, and then copy all of type2’s entries to finalType that finalType doesn’t already contain. Set finalType’s percent hint to type1’s percent hint. Return finalType.

   If type1 and/or type2 contain "percent" with a non-zero value, and type1 and/or type2 contain a key other than "percent" with a non-zero value

     For each base type other than "percent" hint:

     1. Provisionally apply the percent hint hint to both type1 and type2.

     2. If, afterwards, all the entries of type1 with non-zero values are contained in type2 with the same value, and vice versa, then copy all of type1’s entries to finalType, and then copy all of type2’s entries to finalType that finalType doesn’t already contain. Set finalType’s percent hint to hint. Return finalType.

     3. Otherwise, revert type1 and type2 to their state at the start of this loop.

     If the loop finishes without returning finalType, then the types can’t be added. Return failure.

     Note: You can shortcut this in some cases by just checking the sum of all the values of type1 vs type2. If the sums are different, the types can’t be added.

   Otherwise

     The types can’t be added. Return failure.

To apply the percent hint hint to a type, perform the following steps:

1. If type doesn’t contain hint, set type[hint] to 0.

2. If type contains "percent", add type["percent"] to type[hint], then set type["percent"] to 0.

3. Set type’s percent hint to hint.

To multiply two types type1 and type2, perform the following steps:

1. Replace type1 with a fresh copy of type1, and type2 with a fresh copy of type2. Let finalType be a new type with an initially empty ordered map and an initially null percent hint.

2. If both type1 and type2 have non-null percent hints with different values, the types can’t be multiplied. Return failure.

3. If type1 has a non-null percent hint hint and type2 doesn’t, apply the percent hint hint to type2.

   Vice versa if type2 has a non-null percent hint and type1 doesn’t.

4. Copy all of type1’s entries to finalType, then for each baseType → power of type2:

   1. If finalType[baseType] exists, increment its value by power.

   2. Otherwise, set finalType[baseType] to power.

   Set finalType’s percent hint to type1’s percent hint.

5. Return finalType.

To invert a type type, perform the following steps:

1. Let result be a new type with an initially empty ordered map and an initially null percent hint

2. For each unit → exponent of type, set result[unit] to (-1 * exponent).

3. Return result.

A type is said to match a CSS production in some circumstances:

- A type matches <length> if its only non-zero entry is «[ "length" → 1 ]» and its percent hint is null. Similarly for <angle>, <time>, <frequency>, <resolution>, and <flex>.

- A type matches <percentage> if its only non-zero entry is «[ "percent" → 1 ]».

- A type matches <length-percentage> if its only non-zero entry is either «[ "length" → 1 ]» or «[ "percent" → 1 ]» Same for <angle-percentage>, <time-percentage>, etc.

- A type matches <number> if it has no non-zero entries and its percent hint is null.

- A type matches <number-percentage> if it has no non-zero entries, or its only non-zero entry is «[ "percent" → 1 ]».

Many specifications use ''[ <length> | <percentage> ]'' instead of ''<length-percentage>'' in their grammar, and specify in prose that the <length> and <percentage> can be combined. For the purposes of matching, these cases should be treated as <length-percentage>. Similarly for <angle-percentage>, etc.

Note: Types form a semi-group under both addition and a monoid under multiplication (with the multiplicative identity being «[ ]» with a null percent hint), meaning that they’re associative and commutative. Thus the spec can, for example, add an unbounded number of types together unambiguously, rather than having to manually add them pair-wise.

#### 4.3.3. Value + Unit: `CSSUnitValue` objects

Numeric values that can be expressed as a single unit (or a naked number or percentage) are represented as `CSSUnitValue`s.

For example, the value 5px in a stylesheet will be represented by a `CSSUnitValue` with its `value` attribute set to `5` and its `unit` attribute set to `"px"`.

Similarly, the value 10 in a stylesheet will be represented by a `CSSUnitValue` with its `value` attribute set to `10` and its `unit` attribute set to `"number"`.

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(double value, USVString unit)]
    interface CSSUnitValue : CSSNumericValue {
        attribute double value;
        readonly attribute USVString unit;
    };

The `CSSUnitValue(value, unit)` constructor must, when called, perform the following steps:

1. If creating a type from unit returns failure, throw a `TypeError` and abort this algorithm.

2. Return a new `CSSUnitValue` with its `value` internal slot set to value and its `unit` set to unit.

The type of a `CSSUnitValue` is the result of creating a type from its `unit` internal slot.
To create a CSSUnitValue from a pair (num, unit), return a new `CSSUnitValue` object with its `value` internal slot set to num, and its `unit` internal slot set to unit.
For example, creating a CSSUnitValue from `(5, "px")` creates an object equivalent to `new CSSUnitValue(5, "px")`.

Note: This is a spec-internal algorithm, meant simply to make it easier to create unit values in algorithms when needed.

To convert a CSSUnitValue this to a unit unit, perform the following steps:

1. Let old unit be the value of this’s `unit` internal slot, and old value be the value of this’s `value` internal slot.

2. If old unit and unit are not compatible units, return failure.

3. Return a new `CSSUnitValue` whose `unit` internal slot is set to unit, and whose `value` internal slot is set to old value multiplied by the conversation ratio between old unit and unit.

#### 4.3.4. Complex Numeric Values: `CSSMathValue` objects

Numeric values that are more complicated than a single value+unit are represented by a tree of `CSSMathValue` subclasses, eventually terminating in `CSSUnitValue` objects at the leaf nodes. The calc(), min(), and max() functions in CSS are represented in this way.

For example, the CSS value calc(1em + 5px) will be represented by a `CSSMathSum` like `CSSMathSum(CSS.em(1), CSS.px(5))`.

A more complex expression, like calc(1em + 5px * 2), will be represented by a nested structure like `CSSMathSum(CSS.em(1), CSSMathProduct(CSS.px(5), 2))`.

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSMathValue : CSSNumericValue {
        readonly attribute CSSMathOperator operator;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathSum : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathProduct : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish arg)]
    interface CSSMathNegate : CSSMathValue {
        readonly attribute CSSNumericValue value;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish arg)]
    interface CSSMathInvert : CSSMathValue {
        readonly attribute CSSNumericValue value;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathMin : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathMax : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish min, CSSNumberish val, CSSNumberish max)]
    interface CSSMathClamp : CSSMathValue {
        readonly attribute CSSNumericValue min;
        readonly attribute CSSNumericValue val;
        readonly attribute CSSNumericValue max;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSNumericArray {
        iterable<CSSNumericValue>;
        readonly attribute unsigned long length;
        getter CSSNumericValue (unsigned long index);
    };

    enum CSSMathOperator {
        "sum",
        "product",
        "negate",
        "invert",
        "min",
        "max",
        "clamp",
    };

Note: CSSMathValue, being a pure superclass, cannot be directly constructed. It exists solely to host the common attributes of all the "math" operations.

The `operator` attribute of a `CSSMathValue` this must, on getting, return the following string, depending on the interface of this:

`CSSMathSum`

  `"sum"`

`CSSMathProduct`

  `"product"`

`CSSMathMin`

  `"min"`

`CSSMathMax`

  `"max"`

`CSSMathClamp`

  `"clamp"`

`CSSMathNegate`

  `"negate"`

`CSSMathInvert`

  `"invert"`

Note: These are all instances of the `CSSMathOperator` enum.

The `CSSMathSum(...args)` constructor must, when called, perform the following steps:

1. Replace each item of args with the result of rectifying a numberish value for the item.

2. If args is empty, throw a `SyntaxError`.

3. Let type be the result of adding the types of all the items of args. If type is failure, throw a `TypeError`.

4. Return a new `CSSMathSum` whose `values` internal slot is set to args.

The `CSSMathMin(...args)` and `CSSMathMax(...args)` constructors are defined identically to the above, except that in the last step they return a new `CSSMathMin` or `CSSMathMax` object, respectively.

The `CSSMathProduct(...args)` constructor is defined identically to the above, except that in step 3 it multiplies the types instead of adding, and in the last step it returns a `CSSMathProduct`.

The `CSSMathClamp(min, val, max)` constructor must, when called, perform the following steps:

1. Replace min, val, and max with the result of rectifying a numberish value for each.

2. Let type be the result of adding the types of min, val, and max. If type is failure, throw a `TypeError`.

3. Return a new `CSSMathClamp` whose `min`, `val`, and `max` internal slots are set to min, val, and max, respectively.

The `CSSMathNegate(arg)` constructor must, when called, perform the following steps:

1. Replace arg with the result of rectifying a numberish value for arg.

2. Return a new `CSSMathNegate` whose `value` internal slot is set to arg.

The `CSSMathInvert(arg)` constructor is defined identically to the above, except that in the last step it returns a new `CSSMathInvert` object.

The type of a CSSMathValue depends on its class:

`CSSMathSum`
`CSSMathMin`
`CSSMathMax`

  The type is the result of adding the types of each of the items in its `values` internal slot.

`CSSMathClamp`

  The type is the result of adding the types of the `min`, `val`, and `max` internal slots.

`CSSMathProduct`

  The type is the result of multiplying the types of each of the items in its `values` internal slot.

`CSSMathNegate`

  The type is the same as the type of its `value` internal slot.

`CSSMathInvert`

  The type is the same as the type of its `value` internal slot, but with all values negated.

The `length` attribute of `CSSNumericArray` indicates how many `CSSNumericValue`s are contained within the `CSSNumericArray`.

The indexed property getter of `CSSNumericArray` retrieves the `CSSNumericValue` at the provided index.

#### 4.3.5. Numeric Factory Functions

The following factory functions can be used to create new numeric values much less verbosely than using the constructors directly.

    partial namespace CSS {
        CSSUnitValue number(double value);
        CSSUnitValue percent(double value);

        // <length>
        CSSUnitValue em(double value);
        CSSUnitValue ex(double value);
        CSSUnitValue ch(double value);
        CSSUnitValue ic(double value);
        CSSUnitValue rem(double value);
        CSSUnitValue lh(double value);
        CSSUnitValue rlh(double value);
        CSSUnitValue vw(double value);
        CSSUnitValue vh(double value);
        CSSUnitValue vi(double value);
        CSSUnitValue vb(double value);
        CSSUnitValue vmin(double value);
        CSSUnitValue vmax(double value);
        CSSUnitValue cm(double value);
        CSSUnitValue mm(double value);
        CSSUnitValue Q(double value);
        CSSUnitValue in(double value);
        CSSUnitValue pt(double value);
        CSSUnitValue pc(double value);
        CSSUnitValue px(double value);

        // <angle>
        CSSUnitValue deg(double value);
        CSSUnitValue grad(double value);
        CSSUnitValue rad(double value);
        CSSUnitValue turn(double value);

        // <time>
        CSSUnitValue s(double value);
        CSSUnitValue ms(double value);

        // <frequency>
        CSSUnitValue Hz(double value);
        CSSUnitValue kHz(double value);

        // <resolution>
        CSSUnitValue dpi(double value);
        CSSUnitValue dpcm(double value);
        CSSUnitValue dppx(double value);

        // <flex>
        CSSUnitValue fr(double value);
    };

All of the above methods must, when called with a double value, return a new `CSSUnitValue` whose `value` internal slot is set to value and whose `unit` internal slot is set to the name of the method as defined here.

Note: The unit used does not depend on the current name of the function, if it’s stored in another variable; `let foo = CSS.px; let val = foo(5);` does not return a `{value: 5, unit: "foo"}` `CSSUnitValue`. The above talk about names is just a shorthand to avoid defining the unit individually for all ~20 functions.

### 4.4. `CSSTransformValue` objects

`CSSTransformValue` objects represent <transform-list> values, used by the transform property. They "contain" one or more `CSSTransformComponent`s, which represent individual <transform-function> values.

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(sequence<CSSTransformComponent> transforms)]
    interface CSSTransformValue : CSSStyleValue {
        iterable<CSSTransformComponent>;
        readonly attribute unsigned long length;
        getter CSSTransformComponent (unsigned long index);
        setter CSSTransformComponent (unsigned long index, CSSTransformComponent val);

        readonly attribute boolean is2D;
        DOMMatrix toMatrix();
    };

A `CSSTransformValue`’s values to iterate over is a list of `CSSTransformComponent`s.

The `CSSTransformValue(transforms)` constructor must, when called, perform the following steps:

1. If transforms is empty, throw a `TypeError`.

2. Return a new `CSSTransformValue` whose values to iterate over is transforms.

The `is2D` attribute of a `CSSTransformValue` this must, on getting, return `true` if, for each func in this’s values to iterate over, the func’s `is2D` attribute would return `true`; otherwise, the attribute returns `false`.
The `toMatrix()` method of a `CSSTransformValue` this must, when called, perform the following steps:

1. Let matrix be a new `DOMMatrix`, initialized to the identity matrix, with its `is2D` internal slot set to `true`.

2. For each func in this’s values to iterate over:

   1. Let funcMatrix be the `DOMMatrix` returned by calling `toMatrix()` on func.

   2. Set matrix to the result of multiplying matrix and the matrix represented by funcMatrix.

3. Return matrix.

The `length` attribute indicates how many transform components are contained within the `CSSTransformValue`.

They have a `[[values]]` internal slot, which is a list of `CSSTransformComponent` objects. This list is the object’s values to iterate over.

The supported property indexes of a `CSSTransformValue` this are the integers greater than or equal to 0, and less than the size of this’s `[[values]]` internal slot.

To determine the value of an indexed property of a `CSSTransformValue` this and an index n, let values be this’s `[[values]]` internal slot, and return values[n].

To set the value of an existing indexed property of a `CSSTransformValue` this, an index n, and a value new value, let values be this’s `[[values]]` internal slot, and set values[n] to new value.

To set the value of a new indexed property of a `CSSTransformValue` this, an index n, and a value new value, let values be this’s `[[values]]` internal slot. If n is not equal to the size of values, throw a `RangeError`. Otherwise, append new value to values.

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSTransformComponent {
        stringifier;
        attribute boolean is2D;
        DOMMatrix toMatrix();
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue x, CSSNumericValue y, optional CSSNumericValue z)]
    interface CSSTranslate : CSSTransformComponent {
        attribute CSSNumericValue x;
        attribute CSSNumericValue y;
        attribute CSSNumericValue z;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue angle),
     Constructor(CSSNumberish x, CSSNumberish y, CSSNumberish z, CSSNumericValue angle)]
    interface CSSRotate : CSSTransformComponent {
        attribute CSSNumberish x;
        attribute CSSNumberish y;
        attribute CSSNumberish z;
        attribute CSSNumericValue angle;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish x, CSSNumberish y, optional CSSNumberish z)]
    interface CSSScale : CSSTransformComponent {
        attribute CSSNumberish x;
        attribute CSSNumberish y;
        attribute CSSNumberish z;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue ax, CSSNumericValue ay)]
    interface CSSSkew : CSSTransformComponent {
        attribute CSSNumericValue ax;
        attribute CSSNumericValue ay;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue ax)]
    interface CSSSkewX : CSSTransformComponent {
        attribute CSSNumericValue ax;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue ay)]
    interface CSSSkewY : CSSTransformComponent {
        attribute CSSNumericValue ay;
    };

    /* Note that skew(x,y) is *not* the same as skewX(x) skewY(y),
       thus the separate interfaces for all three. */

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue length)]
    interface CSSPerspective : CSSTransformComponent {
        attribute CSSNumericValue length;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(DOMMatrixReadOnly matrix, optional CSSMatrixComponentOptions options = {})]
    interface CSSMatrixComponent : CSSTransformComponent {
        attribute DOMMatrix matrix;
    };

    dictionary CSSMatrixComponentOptions {
        boolean is2D;
    };

The `is2D` attribute indicates whether the transform is 2D or 3D. When it’s `true`, the attributes of the transform that are relevant to 3D transforms (such as the `CSSTranslate.z` attribute) simply have no effect on the transform they represent.

Note: This affects the serialization of the object, and concepts such as the object’s "equivalent 4x4 matrix".

`is2D` Design Considerations

For legacy reasons, 2D and 3D transforms are distinct, even if they have identical effects; a translateZ(0px) has observable effects on a page, even tho it’s defined to be an identity transform, as the UA activates some 3D-based optimizations for the element.

There were several possible ways to reflect this—nullable 3D-related attributes, separate 2D and 3D interfaces, etc—but we chose the current design (an author-flippable switch that dictates the behavior) because it allows authors to, in most circumstances, operate on transforms without having to care whether they’re 2D or 3D, but also prevents "accidentally" flipping a 2D transform into becoming 3D.

The `toMatrix()` method of a `CSSTransformComponent` this must, when called, perform the following steps:

1. Let matrix be a new `DOMMatrix` object, initialized to this’s equivalent 4x4 transform matrix, as defined in CSS Transforms 1 §14 Mathematical Description of Transform Functions, and with its `is2D` internal slot set to the same value as this’s `is2D` internal slot.

   Note: Recall that the `is2D` flag affects what transform, and thus what equivalent matrix, a `CSSTransformComponent` represents.

   As the entries of such a matrix are defined relative to the px unit, if any <length>s in this involved in generating the matrix are not compatible units with px (such as relative lengths or percentages), throw a `TypeError`.

2. Return matrix.

The `CSSTranslate(x, y, z)` constructor must, when invoked, perform the following steps:

1. If x or y don’t match <length-percentage>, throw a `TypeError`.

2. If z was passed, but doesn’t match <length>, throw a `TypeError`.

3. Let this be a new `CSSTranslate` object, with its `x` and `y` internal slots set to x and y.

4. If z was passed, set this’s `z` internal slot to z, and set this’s `is2D` internal slot to `false`.

5. If z was not passed, set this’s `z` internal slot to new unit value of `(0, "px")`, and set this’s `is2D` internal slot to `true`.

6. Return this.

The `CSSRotate(angle)` constructor must, when invoked, perform the following steps:

1. If angle doesn’t match <angle>, throw a `TypeError`.

2. Return a new `CSSRotate` with its `angle` internal slot set to angle, its `x` and `y` internal slots set to new unit values of `(0, "number")`, its `z` internal slot set to a new unit value of `(1, "number")`, and its `is2D` internal slot set to `true`.

The `CSSRotate(x, y, z, angle)` constructor must, when invoked, perform the following steps:

1. If angle doesn’t match <angle>, throw a `TypeError`.

2. Let x, y, and z be replaced by the result of rectifying a numberish value.

3. If x, y, or z don’t match <number>, throw a `TypeError`.

4. Return a new `CSSRotate` with its `angle` internal slot set to angle, its `x`, `y`, `z` internal slots set to x, y, and z, and its `is2D` internal slot set to `false`.

The `x`, `y`, and `z` attributes must, on setting to a new value val, rectify a numberish value from val and set the corresponding internal slot to the result of that.
The `CSSScale(x, y, z)` constructor must, when invoked, perform the following steps:

1. Let x, y, and z (if passed) be replaced by the result of rectifying a numberish value.

2. If x, y, or z (if passed) don’t match <number>, throw a `TypeError`.

3. Let this be a new `CSSScale` object, with its `x` and `y` internal slots set to x and y.

4. If z was passed, set this’s `z` internal slot to z, and set this’s `is2D` internal slot to `false`.

5. If z was not passed, set this’s `z` internal slot to a new unit value of `(1, "number")`, and set this’s `is2D` internal slot to `true`.

6. Return this.

The `x`, `y`, and `z` attributes must, on setting to a new value val, rectify a numberish value from val and set the corresponding internal slot to the result of that.
The `CSSSkew(ax, ay)` constructor must, when invoked, perform the following steps:

1. If ax or ay do not match <angle>, throw a `TypeError`.

2. Return a new `CSSSkew` object with its `ax` and `ay` internal slots set to ax and ay, and its `is2D` internal slot set to `true`.

The `CSSSkewX(ax)` constructor must, when invoked, perform the following steps:

1. If ax does not match <angle>, throw a `TypeError`.

2. Return a new `CSSSkewX` object with its `ax` internal slot set to ax, and its `is2D` internal slot set to `true`.

The `CSSSkewY(ay)` constructor must, when invoked, perform the following steps:

1. If ay does not match <angle>, throw a `TypeError`.

2. Return a new `CSSSkewY` object with its `ay` internal slot set to ay, and its `is2D` internal slot set to `true`.

The `is2D` attribute of a `CSSSkew`, `CSSSkewX`, or `CSSSkewY` object must, on setting, do nothing.

Note: skew(), skewX(), and skewY() functions always represent 2D transforms.

The `CSSPerspective(length)` constructor must, when invoked, perform the following steps:

1. If length does not match <length>, throw a `TypeError`.

2. Return a new `CSSPerspective` object with its `length` internal slot set to length, and its `is2D` internal slot set to `false`.

The `is2D` attribute of a `CSSPerspective` object must, on setting, do nothing.

Note: perspective() functions always represent 3D transforms.

The `CSSMatrixComponent(matrix, options)` constructor must, when invoked, perform the following steps:

1. Let this be a new `CSSMatrixComponent` object with its `matrix` internal slot set to matrix.

2. If options was passed and has a `is2D` field, set this’s `is2D` internal slot to the value of that field.

3. Otherwise, set this’s `is2D` internal slot to the value of matrix’s `is2D` internal slot.

4. Return this.

Each `CSSTransformComponent` can correspond to one of a number of underlying transform functions. For example, a `CSSTranslate` with an x value of 10px and y & z values of 0px could represent any of the following:

- translate(10px)

- translate(10px, 0)

- translateX(10px)

- translate3d(10px, 0, 0)

When stringified, however, it will always print out either translate(10px, 0px) or translate3d(10px, 0px, 0px), depending on whether its `is2D` internal slot is `true` or `false`, respectively.

### 4.5. `CSSImageValue` objects

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSImageValue : CSSStyleValue {
    };

`CSSImageValue` objects represent values for properties that take <image> productions, for example background-image, list-style-image, and border-image-source.

Note: This object is intentionally opaque, and exposes no details of what kind of image it contains, or any aspect of the image. This is because having something to represent images is necessary for Custom Paint, but there are sufficient complexities in getting URL-handling and loading specified firmly that it’s not realistically possible to specify in the timeline of this specification. This will be expanded on in future levels.

If a `CSSImageValue` object represents an <image> that involves a URL (such as url() or image()), the handling of such values is identical to how CSS currently handles them. In particular, resolving relative URLs or fragment URLs has the same behavior as in normal CSS.

For example, relative URLs are resolved against the URL of the stylesheet they’re within (or the document’s URL, if they’re specified in a `style` element or `style` attribute). This resolution doesn’t happen eagerly at parse-time, but at some currently-unspecified point during value computation.

Thus, if an element’s style is set to background-image: url(foo);, and that specified value is extracted via the Typed OM and then set on an element in a different document, both the source and destination elements will resolve the URL differently, as they provide different base URLs.

On the other hand, if the extracted value was a computed value (from `computedStyleMap()`), then it would already be resolved to an absolute URL, and thus would act identically no matter where you later set it to. (Unless it was a fragment URL, which CSS treats differently and never fully resolves, so it always resolves against the current document.)

## 5. `CSSStyleValue` Reification

This section describes how Typed OM objects are constructed from internal representations, a process called reification.

Some general principles apply to all reification, and so aren’t stated in each individual instance:

- If an internal representation is from a list-valued property, this list defines how to reify a single iteration of the property; multiple iterations are reflected by returning multiple values from `StylePropertyMap`.`getAll()`.

- If an internal representation contains a var() reference, then it is reified by reifying a list of component values, regardless of what property it is for.

### 5.1. Property-specific Rules

The following list defines the reification behavior for every single property in CSS, for both specified and computed values.

unregistered custom properties

  For both specified and computed values, reify a list of component values from the value, and return the result.

registered custom properties

  Reified as described by CSS Properties and Values API 1 §5.2 CSSStyleValue Reification.

align-content
align-items

  For both specified and computed values:

  1. If the value is normal or stretch, reify an identifier from the value and return the result.

  2. If the value is baseline or first baseline,, reify an identifier "baseline" and return the result.

  3. If the value is a <self-position> with no <overflow-position>, reify an identifier from the value and return the result.

  4. Otherwise, reify as a `CSSStyleValue` and return the result.

align-self

  For both specified and computed values:

  1. If the value is auto, normal, or stretch, reify an identifier from the value and return the result.

  2. If the value is baseline or first baseline,, reify an identifier "baseline" and return the result.

  3. If the value is a <self-position> with no <overflow-position>, reify an identifier from the value and return the result.

  4. Otherwise, reify as a `CSSStyleValue` and return the result.

alignment-baseline

  For both specified and computed values, reify an identifier from the value and return the result.

all

  For both specified and computed values, reify an identifier from the value and return the result.

animation-composition

  For both specified and computed values, reify an identifier from the value and return the result.

appearance

  For both specified and computed values, reify an identifier from the value and return the result.

azimuth
  For specified values:

    1. If the value is an <angle>, reify a numeric value from the value and return the result.

    2. If the value is a single keyword, reify an identifier from the value and return the result.

    3. Otherwise, reify as a `CSSStyleValue` and return the result.

  For computed values:

    Reify a numeric value from the angle and return the result.

backdrop-filter

  For both specified and computed values:

  1. If the value is none, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

backface-visibility

  For both specified and computed values, reify an identifier from the value and return the result.

background

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

background-attachment

  For both specified and computed values, reify an identifier from the value and return the result.

background-blend-mode

  For both specified and computed values, reify an identifier from the value and return the result.

background-clip

  For both specified and computed values, reify an identifier from the value and return the result.

background-color

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

background-image

  For both specified and computed values:

  1. If the value is none, reify an identifier from the value and return the result.

  2. If the value is a url() function, reify a url from the value and return the result.

  3. Otherwise, reify an image from the value and return the result.

background-image-transform

  For both specified and computed values, reify an identifier from the value and return the result.

background-position

  For both specified and computed values, reify a position from the value and return the result.

background-repeat

  For both specified and computed values:

  1. If the value is a single keyword, or the same keyword repeated twice, reify an identifier from the keyword and return the result.

  2. If the value is repeat no-repeat, reify an identifier "repeat-x" and return the result.

  3. If the value is no-repeat repeat, reify an identifier "repeat-y" and return the result.

  4. Otherwise, reify to a `CSSStyleValue` and return the result.

baseline-shift

  For both specified and computed values:

  1. If the value is sub or super, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

block-size

  Same as for width

block-step

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

block-step-align

  For both specified and computed values, reify an identifier from the value and return the result.

block-step-insert

  For both specified and computed values, reify an identifier from the value and return the result.

block-step-round

  For both specified and computed values, reify an identifier from the value and return the result.

block-step-size

  For both specified and computed values:

  1. If the value is none, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

bookmark-label

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

bookmark-level

  For both specified and computed values:

  1. If the value is none, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

bookmark-state

  For both specified and computed values, reify an identifier from the value and return the result.

border

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

border-block

  Same as border-block-start

border-block-color

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

border-block-end

  Same as border-block-start

border-block-end-color

  Same as border-top-color

border-block-end-style

  Same as border-top-style

border-block-end-width

  Same as border-top-width

border-block-start

  Same as border-top

border-block-start-color

  Same as border-top-color

border-block-start-style

  Same as border-top-style

border-block-start-width

  Same as border-top-width

border-block-style

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

border-block-width

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

border-bottom

  Same as border-top

border-bottom-color

  Same as border-top-color

border-bottom-style

  Same as border-top-style

border-bottom-width

  Same as border-top-width

border-boundary

  For both specified and computed values, reify an identifier from the value and return the result.

border-collapse

  For both specified and computed values, reify an identifier from the value and return the result.

border-color

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

border-image-transform

  For both specified and computed values, reify an identifier from the value and return the result.

border-inline
border-inline-color
border-inline-end
border-inline-end-color
border-inline-end-style
border-inline-end-width
border-inline-start
border-inline-start-color
border-inline-start-style
border-inline-start-width
border-inline-style
border-inline-width
border-left

  Same as border-top

border-left-color

  Same as border-top-color

border-left-style

  Same as border-top-style

border-left-width

  Same as border-top-width

border-radius

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

border-right

  Same as border-top

border-right-color

  Same as border-top-color

border-right-style

  Same as border-top-style

border-right-width

  Same as border-top-width

border-spacing
border-style
border-top

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

border-top-color

  For both specified and computed values:

  1. If the value is currentcolor, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

border-top-style

  For both specified and computed values, reify an identifier from the value and return the result.

border-top-width

  For both specified and computed values:

  1. If the value is a <length>, reify a numeric value from the value and return the result.

  2. Otherwise, reify an identifier from the value and return the result.

border-width

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

bottom

  For both specified and computed values:

  1. If the value is auto, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

box-decoration-break
box-sizing

  For both specified and computed values, reify an identifier from the value and return the result.

box-snap
break-after
break-before
break-inside
caption-side
caret
caret-color

  For both specified and computed values:

  1. If the value is currentcolor, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

caret-shape
clear

  For both specified and computed values, reify an identifier from the value and return the result.

clip
clip-path
clip-rule
color

  For both specified and computed values:

  1. If the value is currentcolor, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

color-adjust
color-interpolation
color-rendering
column-gap
column-span
contain
content
continue
copy-into
counter-increment
counter-reset
counter-set
cue
cue-after
cue-before
cursor
cx
cy
d
direction

  For both specified and computed values, reify an identifier from the value and return the result.

display

  For both specified and computed values, reify an identifier from the value and return the result.

dominant-baseline
elevation
empty-cells

  For both specified and computed values, reify an identifier from the value and return the result.

fill
fill-break
fill-color
fill-image
fill-opacity
fill-origin
fill-position
fill-repeat
fill-rule
fill-size
'filter-margin-top, filter-margin-right, filter-margin-bottom, filter-margin-left'
flex
flex-basis
flex-direction
flex-flow
flex-grow
flex-shrink
flex-wrap
float

  For both specified and computed values, reify an identifier from the value and return the result.

float-defer
font

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

font-family

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

font-language-override

  For both specified and computed values:

  1. If the value is normal, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

font-max-size

  For both specified and computed values:

  1. If the value is an <absolute-size>, <relative-size> or infinity, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

font-min-size

  Same as font-size

font-optical-sizing

  For both specified and computed values, reify an identifier from the value and return the result.

font-palette

  For both specified and computed values:

  1. If the value is normal, light or dark, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

font-presentation

  For both specified and computed values, reify an identifier from the value and return the result.

font-size

  For both specified and computed values:

  1. If the value is an <absolute-size> or <relative-size>, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

font-size-adjust

  For both specified and computed values:

  1. If the value is none, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

font-stretch

  For both specified and computed values:

  1. If the value is a <percentage>, reify a numeric value from the value and return the result.

  2. Otherwise, reify an identifier from the value and return the result.

font-style

  For both specified and computed values, reify an identifier from the value and return the result.

font-synthesis

  For both specified and computed values:

  1. If the value is none, weight, style or small-caps, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

font-variant

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

font-variant-alternates

  For both specified and computed values:

  1. If the value is none or historical-forms, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

font-variant-emoji

  For both specified and computed values, reify an identifier from the value and return the result.

font-variation-settings

  For both specified and computed values:

  1. If the value is normal, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

font-weight

  For both specified and computed values:

  1. If the value is a <number>, reify a numeric value from the value and return the result.

  2. Otherwise, reify an identifier from the value

gap
globalcompositeoperation
glyph-orientation-vertical
grid
grid-area
grid-auto-columns
grid-auto-flow
grid-auto-rows
grid-column
grid-column-end
grid-column-gap
grid-column-start
grid-gap
grid-row
grid-row-end
grid-row-gap
grid-row-start
grid-template
grid-template-areas
grid-template-columns
grid-template-rows
height

  For both specified and computed values:

  1. If the value is auto, reify an identifier from the value and return the result.

  2. If the value is a <length> or <percentage>, reify a numeric value from the value and return the result.

image-rendering
image-resolution
initial-letter
initial-letter-align
initial-letter-wrap
inline-size
inset
inset-block
inset-block-end
inset-block-start
inset-inline
inset-inline-end
inset-inline-start
isolation
justify-content
justify-items
justify-self
left

  For both specified and computed values:

  1. If the value is auto, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

letter-spacing
line-grid
line-height

  For both specified and computed values:

  1. If the value is normal, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

line-height-step
line-snap
list-style
list-style-image

  For both specified and computed values:

  1. If the value is none, reify an identifier from the value and return the result.

  2. If the value is a url() function, reify a url from the value and return the result.

  3. Otherwise, reify an image from the value and return the result.

list-style-position

  For both specified and computed values, reify an identifier from the value and return the result.

list-style-type
margin

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

margin-block
margin-block-end
margin-block-start
margin-bottom

  Same as margin-top

margin-inline
margin-inline-end
margin-inline-start
margin-left

  Same as margin-top

margin-right

  Same as margin-top

margin-top

  For both specified and computed values:

  1. If the value is auto, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

marker
marker-end
marker-mid
marker-side
marker-start
mask
mask-border
mask-border-mode
mask-border-outset
mask-border-repeat
mask-border-slice
mask-border-source
mask-border-width
mask-clip
mask-composite
mask-image

  For both specified and computed values:

  1. If the value is none, reify an identifier from the value and return the result.

  2. Otherwise, reify an image from the value and return the result.

mask-mode
mask-origin
mask-position
mask-repeat
mask-size
mask-type
max-block-size
max-height
max-inline-size
max-lines
max-width
min-block-size
min-height
min-inline-size
min-width
mix-blend-mode
nav-down
nav-left
nav-right
nav-up
object-fit
offset
offset-after
offset-anchor
offset-before
offset-distance
offset-end
offset-path
offset-position
offset-rotate
offset-start
opacity

  For both specified and computed values, reify a numeric value from the value and return the result.

order
orphans
outline
outline-color

  For both specified and computed values:

  1. If the value is currentcolor, reify an identifier from the value and return the result.

  2. Otherwise, reify as a `CSSStyleValue` and return the result.

outline-offset
outline-style

  For both specified and computed values, reify an identifier from the value and return the result.

outline-width
overflow

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

overflow-anchor

  For both specified and computed values, reify an identifier from the value and return the result.

overflow-x

  For both specified and computed values, reify an identifier from the value and return the result.

overflow-y

  For both specified and computed values, reify an identifier from the value and return the result.

padding

  For both specified and computed values, reify as a `CSSStyleValue` and return the result.

padding-block
padding-block-end
padding-block-start
padding-bottom

  Same as padding-top

padding-inline
padding-inline-end
padding-inline-start
padding-left

  Same as padding-top

padding-right

  Same as padding-top

padding-top

  For both specified and computed values, reify a numeric value from the value and return the result.

page
page-break-after
page-break-before
page-break-inside
paint-order
pause
pause-after
pause-before
perspective
perspective-origin
pitch
pitch-range
place-content
place-items
place-self
play-during
pointer-events
position

  For both specified and computed values, reify an identifier from the value and return the result.

presentation-level
quotes
r
region-fragment
resize

  For both specified and computed values, reify an identifier from the value and return the result.

rest
rest-after
rest-before
richness
right

  For both specified and computed values:

  1. If the value is auto, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

rotate
row-gap
ruby-align
ruby-merge
ruby-position
rx
ry
scale
scroll-behavior
scroll-margin
scroll-margin-block
scroll-margin-block-end
scroll-margin-block-start
scroll-margin-bottom
scroll-margin-inline
scroll-margin-inline-end
scroll-margin-inline-start
scroll-margin-left
scroll-margin-right
scroll-margin-top
scroll-padding
scroll-padding-block
scroll-padding-block-end
scroll-padding-block-start
scroll-padding-bottom
scroll-padding-inline
scroll-padding-inline-end
scroll-padding-inline-start
scroll-padding-left
scroll-padding-right
scroll-padding-top
scroll-snap-align
scroll-snap-stop
scroll-snap-type
scrollbar-3dlight-color
scrollbar-arrow-color
scrollbar-base-color
scrollbar-darkshadow-color
scrollbar-face-color
scrollbar-gutter
scrollbar-highlight-color
scrollbar-shadow-color
scrollbar-track-color
shape-inside
shape-margin
shape-padding
shape-rendering
shape-subtract
size
solid-color
solid-opacity
speak
speak-as
speak-header
speak-numeral
speak-punctuation
speech-rate
stop-color
stop-opacity
stress
stroke
stroke-align
stroke-break
stroke-color
stroke-dash-corner
stroke-dash-justify
stroke-dasharray
stroke-dashoffset
stroke-image
stroke-linecap
stroke-linejoin
stroke-miterlimit
stroke-opacity
stroke-origin
stroke-position
stroke-repeat
stroke-size
stroke-width
table-layout
text-align

  For both specified and computed values, reify an identifier from the value and return the result.

text-anchor
text-combine-upright
text-decoration
text-decoration-fill
text-decoration-skip
text-decoration-skip-ink
text-decoration-stroke
text-decoration-width
text-emphasis-skip
text-indent
text-orientation
text-overflow
text-rendering
text-size-adjust
text-transform

  For both specified and computed values, reify an identifier from the value and return the result.

text-underline-offset
top

  For both specified and computed values:

  1. If the value is auto, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

transform-style
transition
transition-delay
transition-duration
transition-property
transition-timing-function
translate
unicode-bidi
user-select
vector-effect
vertical-align

  For both specified and computed values:

  1. If the value is baseline, reify an identifier from the value and return the result.

  2. Otherwise, reify a numeric value from the value and return the result.

visibility

  For both specified and computed values, reify an identifier from the value and return the result.

voice-balance
voice-duration
voice-family
voice-pitch
voice-range
voice-rate
voice-stress
voice-volume
volume
white-space

  For both specified and computed values, reify an identifier from the value and return the result.

widows
width

  For both specified and computed values:

  1. If the value is auto, reify an identifier from the value and return the result.

  2. If the value is a <length> or <percentage>, reify a numeric value from the value and return the result.

will-change
word-spacing
writing-mode
x
y
z-index

### 5.2. Unrepresentable Values

Not all internal representations are simple enough to be reified with the current set of `CSSStyleValue` subclasses. When this is the case, the property is reified as a CSSStyleValue for a particular property, ensuring that it can be used as a value for that property, and nothing else.

To reify as a CSSStyleValue a value for a property:

1. Return a new `CSSStyleValue` object representing value whose `[[associatedProperty]]` internal slot is set to property.

### 5.3. Raw CSS tokens: properties with var() references

Regardless of what the property’s grammar is otherwise, a property value with an un-substituted var() reference is represented as a list of component values, which becomes a `CSSUnparsedValue` in the Typed OM.

To reify a list of component values from a list:

1. Replace all var() references in list with `CSSVariableReferenceValue` objects, as described in § 5.4 var() References.

2. Replace each remaining maximal subsequence of component values in list with a single string of their concatenated serializations.

3. Return a new `CSSUnparsedValue` whose `[[tokens]]` slot is set to list.

The string "calc(42px + var(--foo, 15em) + var(--bar, var(--far) + 15px))" is converted into a `CSSUnparsedValue` that contains a sequence with:

- the string "calc(42px + "

- a `CSSVariableReferenceValue` with:

  - `variable` "--foo"

  - `fallback` a `CSSUnparsedValue` with a single-valued sequence containing " 15em"

- the string " + "

- a `CSSVariableReferenceValue` with:

  - `variable` "--bar"

  - `fallback` a `CSSUnparsedValue` with a sequence containing:

    - the string " "

    - a `CSSVariableReferenceValue` with

      - `variable` "--far"

      - `fallback` null

    - the string " + 15px"

- the string ")"

### 5.4. var() References

var() references become `CSSVariableReferenceValue`s in the Typed OM.

To reify a var() reference var:

1. Let object be a new `CSSVariableReferenceValue`.

2. Set object’s `variable` internal slot to the serialization of the <custom-ident> providing the variable name.

3. If var has a fallback value, set object’s `fallback` internal slot to the result of reifying the fallback’s component values. Otherwise, set it to `null`.

4. Return object.

### 5.5. Identifier Values

CSS identifiers become `CSSKeywordValue`s in the Typed OM.

To reify an identifier ident:

1. Return a new `CSSKeywordValue` with its `value` internal slot set to the serialization of ident.

### 5.6. <number>, <percentage>, and <dimension> values

CSS <number>, <percentage>, and <dimension> values become `CSSNumericValue`s in the Typed OM.

To reify a numeric value num:

1. If num is a math function, reify a math expression from num and return the result.

2. If num is the unitless value 0 and num is a <dimension>, return a new `CSSUnitValue` with its `value` internal slot set to 0, and its `unit` internal slot set to "px".

3. Return a new `CSSUnitValue` with its `value` internal slot set to the numeric value of num, and its `unit` internal slot set to "number" if num is a <number>, "percent" if num is a <percentage>, and num’s unit if num is a <dimension>.

   If the value being reified is a computed value, the unit used must be the appropriate canonical unit for the value’s type, with the numeric value scaled accordingly.

   For example, if an element has `style="width: 1in;"`, `el.attributeStyleMap.get('width')` will return `CSS.in(1)`, but `el.computedStyleMap.get('width')` will return `CSS.px(96)`, as px is the canonical unit for absolute lengths.

To reify a math expression num:

1. If num is a min() or max() expression:

   1. Let values be the result of reifying the arguments to the expression, treating each argument as if it were the contents of a calc() expression.

   2. Return a new `CSSMathMin` or `CSSMathMax` object, respectively, with its `values` internal slot set to values.

2. Assert: Otherwise, num is a calc().

3. Turn num’s argument into an expression tree using standard PEMDAS precedence rules, with the following exceptions/clarification:

   - Treat subtraction as instead being addition, with the RHS argument instead wrapped in a special "negate" node.

   - Treat division as instead being multiplication, with the RHS argument instead wrapped in a special "invert" node.

   - Addition and multiplication are N-ary; each node can have any number of arguments.

   - If an expression has only a single value in it, and no operation, treat it as an addition node with the single argument.

4. Recursively transform the expression tree into objects, as follows:

   addition node

     becomes a new `CSSMathSum` object, with its `values` internal slot set to its list of arguments

   multiplication node

     becomes a new `CSSMathProduct` object, with its `values` internal slot set to its list of arguments

   negate node

     becomes a new `CSSMathNegate` object, with its `value` internal slot set to its argument

   invert node

     becomes a new `CSSMathInvert` object, with its `value` internal slot set to its argument

   leaf node

     reified as appropriate

For example, calc(1px - 2 * 3em) produces the structure:

    CSSMathSum(
        CSS.px(1),
        CSSMathNegate(
            CSSMathProduct(
                2,
                CSS.em(3)
            )
        )
    )

Note that addition and multiplication are N-ary, so calc(1px + 2px + 3px) produces the structure:

    CSSMathSum(
        CSS.px(1),
        CSS.px(2),
        CSS.px(3)
    )

but calc(calc(1px + 2px) + 3px) produces the structure:

    CSSMathSum(
        CSSMathSum(
            CSS.px(1),
            CSS.px(2)
        ),
        CSS.px(3)
    )

Note: The value computation process may transform different units into identical ones, simplifying the resulting expression. For example, calc(1px + 2em) as a specified value results in a `CSSMathSum(CSS.px(1), CSS.em(2))`, but as a computed value will give `CSS.px(33)` or similar (depending on the value of an em in that context).

### 5.7. <transform-list> and <transform-function> values

CSS <transform-list> values become `CSSTransformValue`s in the Typed OM, while CSS <transform-function> values become `CSSTransformComponent`s.

To reify a <transform-list> list:

1. Return a new `CSSTransformValue` whose values to iterate over are the result of mapping the reify a <transform-function> algorithm over list.

To reify a <transform-function> func, perform the appropriate set of steps below, based on func:

matrix()
matrix3d()

  1. Return a new `CSSMatrixComponent` object, whose `matrix` internal slot is set to a 4x4 matrix representing the same information as func, and whose `is2D` internal slot is `true` if func is matrix(), and `false` otherwise.

translate()
translateX()
translateY()
translate3d()
translateZ()

  1. Return a new `CSSTranslate` object, whose `x`, `y`, and `z` internal slots are set to the reification of the specified x/y/z offsets, or the reification of 0px if not specified in func, and whose `is2D` internal slot is `true` if func is translate(), translateX(), or translateY(), and `false` otherwise.

scale()
scaleX()
scaleY()
scale3d()
scaleZ()

  1. Return a new `CSSScale` object, whose `x`, `y`, and `z` internal slots are set to the specified x/y/z scales, or to 1 if not specified in func and whose `is2D` internal slot is `true` if func is scale(), scaleX(), or scaleY(), and `false` otherwise.

rotate()
rotate3d()
rotateX()
rotateY()
rotateZ()

  1. Return a new `CSSRotate` object, whose `angle` internal slot is set to the reification of the specified angle, and whose `x`, `y`, and `z` internal slots are set to the specified rotation axis coordinates, or the implicit axis coordinates if not specified in func and whose `is2D` internal slot is `true` if func is rotate(), and `false` otherwise.

skew()

  1. Return a new `CSSSkew` object, whose `ax` and `ay` internal slots are set to the reification of the specified x and y angles, or the reification of 0deg if not specified in func, and whose `is2D` internal slot is `true`.

skewX()

  1. Return a new `CSSSkewX` object, whose `ax` internal slot is set to the reification of the specified x angle, or the reification of 0deg if not specified in func, and whose `is2D` internal slot is `true`.

skewY()

  1. Return a new `CSSSkewY` object, whose `ay` internal slot is set to the reification of the specified y angle, or the reification of 0deg if not specified in func, and whose `is2D` internal slot is `true`.

perspective()

  1. Return a new `CSSPerspective` object, whose `length` internal slot is set to the reification of the specified length and whose `is2D` internal slot is `false`.

### 5.8. <url> (and subtype) Values

Resource references are reified by determining whether the reference is invalid (in which case `state` is set to error) or requires network data (in which case `state` is set to loading). If data is not required and the reference is valid then `state` is set to loaded.

If `state` is set to loading then the image reference is reevaluated once the pending data becomes available, according to the same rules referenced above.

Reification can not fail for `CSSResourceValue` objects.

The string 'url(bike.png)' is converted into a `CSSURLImageValue` with `state` set to unloaded and the `url` set to bike.png. The `intrinsicWidth`, `intrinsicHeight` and `intrinsicRatio` are all set to null.

## 6. `CSSStyleValue` Serialization

The way that a `CSSStyleValue` serializes is dependent on how the value was constructed.

if the value was constructed from a USVString

  the serialization is the USVString from which the value was constructed.

otherwise, if the value was constructed using an IDL constructor

  the serialization is specified in the sections below.

otherwise, if the value was extracted from the CSSOM

  the serialization is specified in § 6.7 Serialization from CSSOM Values below.

For example:

    var length1 = CSSNumericValue.parse("42.0px");
    length1.toString(); // "42.0px"

    var length2 = CSS.px(42.0);
    length2.toString(); // "42px";

    element.style.width = "42.0px";
    var length3 = element.attributeStyleMap.get('width');
    length3.toString(); // "42px";

### 6.1. `CSSUnparsedValue` Serialization

To serialize a `CSSUnparsedValue` this:

1. Let s initially be the empty string.

2. For each item in this’s `[[tokens]]` internal slot:

   1. If item is a `USVString`, append it to s.

   2. Otherwise, item is a `CSSVariableReferenceValue`. Serialize it, then append the result to s.

3. Return s.

To serialize a `CSSVariableReferenceValue` this:

1. Let s initally be "var(".

2. Append this’s `variable` internal slot to s.

3. If this’s `fallback` internal slot is not `null`, append ", " to s, then serialize the `fallback` internal slot and append it to s.

4. Append ")" to s and return s.

### 6.2. `CSSKeywordValue` Serialization

To serialize a `CSSKeywordValue` this:

1. Return this’s `value` internal slot.

### 6.3. `CSSUnitValue` Serialization

To serialize a `CSSUnitValue` this:

1. Let value and unit be this‘s `value` and `unit` internal slots.

2. Set s to the result of serializing a <number> from value, per CSSOM 1 §5.7.2 Serializing CSS Values.

3. If unit is "number", return s.

4. Otherwise, if unit is "percent", append "%" to s, then return s.

5. Otherwise, append unit to s, then return s.

### 6.4. `CSSMathValue` Serialization

To serialize a `CSSMathValue` this, with additional flags nested, a boolean (defaulting to false if unspecified), and paren-less, a boolean (defaulting to false if unspecified):

1. Let s initially be the empty string.

2. If this is a `CSSMathMin` or `CSSMathMax`:

   1. Append "min(" or "max(" to s, as appropriate.

   2. For each arg in this’s `values` internal slot, serialize arg with nested and paren-less both true, and append the result to s, appending a ", " between successive values.

   3. Append ")" to s and return s.

3. Otherwise, if this is a `CSSMathSum`:

   1. If paren-less is true, continue to the next step; otherwise, if nested is true, append "(" to s; otherwise, append "calc(" to s.

   2. Serialize the first item in this’s `values` internal slot with nested set to true, and append the result to s.

   3. For each arg in this’s `values` internal slot beyond the first:

      1. If arg is a `CSSMathNegate`, append " - " to s, then serialize arg’s `value` internal slot with nested set to true, and append the result to s.

      2. Otherwise, append " + " to s, then serialize arg with nested set to true, and append the result to s.

   4. If paren-less is false, append ")" to s,

   5. Return s.

4. Otherwise, if this is a `CSSMathNegate`:

   1. If paren-less is true, continue to the next step; otherwise, if nested is true, append "(" to s; otherwise, append "calc(" to s.

   2. Append "-" to s.

   3. Serialize this’s `value` internal slot with nested set to true, and append the result to s.

   4. If paren-less is false, append ")" to s,

   5. Return s.

5. Otherwise, if this is a `CSSMathProduct`:

   1. If paren-less is true, continue to the next step; otherwise, if nested is true, append "(" to s; otherwise, append "calc(" to s.

   2. Serialize the first item in this’s `values` internal slot with nested set to true, and append the result to s.

   3. For each arg in this’s `values` internal slot beyond the first:

      1. If arg is a `CSSMathInvert`, append " / " to s, then serialize arg’s `value` internal slot with nested set to true, and append the result to s.

      2. Otherwise, append " * " to s, then serialize arg with nested set to true, and append the result to s.

   4. If paren-less is false, append ")" to s,

   5. Return s.

6. Otherwise, if this is a `CSSMathInvert`:

   1. If paren-less is true, continue to the next step; otherwise, if nested is true, append "(" to s; otherwise, append "calc(" to s.

   2. Append "1 / " to s.

   3. Serialize this’s `value` internal slot with nested set to true, and append the result to s.

   4. If paren-less is false, append ")" to s,

   5. Return s.

### 6.5. `CSSTransformValue` and `CSSTransformComponent` Serialization

To serialize a `CSSTransformValue` this:

1. Return the result of serializing each item in this’s values to iterate over, then concatenating them separated by " ".

To serialize a `CSSTranslate` this:

1. Let s initially be the empty string.

2. If this’s `is2D` internal slot is `false`:

   1. Append "translate3d(" to s.

   2. Serialize this’s `x` internal slot, and append it to s.

   3. Append ", " to s.

   4. Serialize this’s `y` internal slot, and append it to s.

   5. Append ", " to s.

   6. Serialize this’s `z` internal slot, and append it to s.

   7. Append ")" to s, and return s.

3. Otherwise:

   1. Append "translate(" to s.

   2. Serialize this’s `x` internal slot, and append it to s.

   3. Append ", " to s.

   4. Serialize this’s `y` internal slot, and append it to s.

   5. Append ")" to s, and return s.

To serialize a `CSSRotate` this:

1. Let s initially be the empty string.

2. If this’s `is2D` internal slot is `false`:

   1. Append "rotate3d(" to s.

   2. Serialize this’s `x` internal slot, and append it to s.

   3. Append ", " to s.

   4. Serialize this’s `y` internal slot, and append it to s.

   5. Append ", " to s.

   6. Serialize this’s `z` internal slot, and append it to s.

   7. Append "," to s.

   8. Serialize this’s `angle` internal slot, and append it to s.

   9. Append ")" to s, and return s.

3. Otherwise:

   1. Append "rotate(" to s.

   2. Serialize this’s `angle` internal slot, and append it to s.

   3. Append ")" to s, and return s.

To serialize a `CSSScale` this:

1. Let s initially be the empty string.

2. If this’s `is2D` internal slot is `false`:

   1. Append "scale3d(" to s.

   2. Serialize this’s `x` internal slot, and append it to s.

   3. Append ", " to s.

   4. Serialize this’s `y` internal slot, and append it to s.

   5. Append ", " to s.

   6. Serialize this’s `z` internal slot, and append it to s.

   7. Append ")" to s, and return s.

3. Otherwise:

   1. Append "scale(" to s.

   2. Serialize this’s `x` internal slot, and append it to s.

   3. If this’s `x` and `y` internal slots are equal numeric values, append ")" to s and return s.

   4. Otherwise, append ", " to s.

   5. Serialize this’s `y` internal slot, and append it to s.

   6. Append ")" to s, and return s.

To serialize a `CSSSkew` this:

1. Let s initially be "skew(".

2. Serialize this’s `ax` internal slot, and append it to s.

3. If this’s `ay` internal slot is a `CSSUnitValue` with a `value` of `0`, then append ")" to s and return s.

4. Otherwise, append ", " to s.

5. Serialize this’s `ay` internal slot, and append it to s.

6. Append ")" to s, and return s.

To serialize a `CSSSkewX` this:

1. Let s initially be "skewX(".

2. Serialize this’s `ax` internal slot, and append it to s.

3. Append ")" to s, and return s.

To serialize a `CSSSkewY` this:

1. Let s initially be "skewY(".

2. Serialize this’s `ay` internal slot, and append it to s.

3. Append ")" to s, and return s.

To serialize a `CSSPerspective` this:

1. Let s initially be "perspective(".

2. Serialize this’s `length` internal slot, and append it to s.

3. Append ")" to s, and return s.

To serialize a `CSSMatrixComponent` this:

1. Return the serialization of this’s `matrix` internal slot.

### 6.6. `CSSURLImageValue` Serialization

`CSSURLImageValue` objects are serialized to the string given by 'url("' + `url` + '")'.

### 6.7. Serialization from CSSOM Values

`CSSStyleValue` objects produced by the user agent from values in the CSSOM, rather than directly constructed by the author, are serialized according to the following rules, depending on the property they came from:

background-color

  1. If the value is the currentcolor keyword, return "currentcolor".

  2. Otherwise, return the result of serializing the <color> value.

border-color

  1. If the value is the currentcolor keyword, return "currentcolor".

  2. Otherwise, return the result of serializing the <color> value.

border-image

  1. Let values initially be the empty list.

  2. If border-image-source is not none, serialize border-image-source and append it to values.

  3. If border-image-slice does not specify 100% for all sides and omits the fill keyword, serialize border-image-slice and append it to values.

  4. If border-image-width does not specify 1 for all sides, append "/ " (U+002F FORWARD SLASH followed by U+0020 SPACE) to the result of serializing border-image-width and append it to values.

  5. If border-image-outset does not specify 0 for all sides:

     1. If the previous border-image-width step did not append anything to values, let prefix be "// " (two U+002F FORWARD SLASH characters followed by U+0020 SPACE); otherwise let prefix be "/ " (U+002F FORWARD SLASH followed by U+0020 SPACE)

     2. Append prefix to the result of serializing border-image-outset and append it to values.

  6. If border-image-repeat is not stretch in both axises, serialize border-image-repeat and append it to values.

  7. If values is empty, append "none" to values.

  8. Return the result of concatenating all the items in values, separated by " " (U+0020 SPACE).

bottom

  1. If the value is the auto keyword, return "auto".

  2. If the value is of type <length>, return the result of serializing the <length> value.

  3. Otherwise, return the result of serializing the <percentage> value.

color

  1. If the value is the currentcolor keyword, return "currentcolor".

  2. Otherwise, return the result of serializing the <color> value.

left

  1. If the value is the auto keyword, return "auto".

  2. If the value is of type <length>, return the result of serializing the <length> value.

  3. Otherwise, return the result of serializing the <percentage> value.

opacity

  1. If the value is of type <number>, return the result of serializing the <number> value.

  2. Otherwise, return the result of serializing the <percentage> value.

right

  1. If the value is the auto keyword, return "auto".

  2. If the value is of type <length>, return the result of serializing the <length> value.

  3. Otherwise, return the result of serializing the <percentage> value.

top

  1. If the value is the auto keyword, return "auto".

  2. If the value is of type <length>, return the result of serializing the <length> value.

  3. Otherwise, return the result of serializing the <percentage> value.

## 7. Security Considerations

There are no known security issues introduced by these features.

## 8. Privacy Considerations

There are no known privacy issues introduced by these features.

## Conformance

### Document conventions

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

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

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

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.

Advisements are normative sections styled to evoke special attention and are set apart from other normative text with `<strong class="advisement">`, like this: UAs MUST provide an accessible alternative.

### Conformance classes

Conformance to this specification is defined for three conformance classes:

style sheet
  A CSS style sheet.
renderer
  A UA that interprets the semantics of a style sheet and renders documents that use them.
authoring tool
  A UA that writes a style sheet.

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

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

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

### Partial implementations

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

#### Implementations of Unstable and Proprietary Features

To avoid clashes with future stable CSS features, the CSSWG recommends following best practices for the implementation of unstable features and proprietary extensions to CSS.

### Non-experimental implementations

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

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

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

## Index

### Terms defined by this specification

- add, in §4.3.2
- add(), in §4.3.1
- addition, in §4.3.2
- add two types, in §4.3.2
- add(...values), in §4.3.1
- "angle", in §4.3.1
- angle
  - attribute for CSSRotate, in §4.4
  - dict-member for CSSNumericType, in §4.3.1
- append(property), in §3
- append(property, ...values), in §3
- apply the percent hint, in §4.3.2
- [[associatedProperty]], in §2.1
- attributeStyleMap, in §3.2
- ax
  - attribute for CSSSkew, in §4.4
  - attribute for CSSSkewX, in §4.4
- ay
  - attribute for CSSSkew, in §4.4
  - attribute for CSSSkewY, in §4.4
- base type, in §4.3.2
- ch(value), in §4.3.5
- "clamp", in §4.3.4
- clear(), in §3
- cm(value), in §4.3.5
- computedStyleMap(), in §3.1
- [[computedStyleMapCache]], in §3.1
- Computed StylePropertyMap, in §3.1
- convert a CSSUnitValue, in §4.3.3
- create a CSSUnitValue from a pair, in §4.3.3
- create a CSSUnitValue from a sum value item, in §4.3.1
- create an internal representation, in §3
- create a sum value, in §4.3.1
- create a type, in §4.3.2
- create a type from a unit map, in §4.3.1
- creating a sum value, in §4.3.1
- creating a type, in §4.3.2
- CSSImageValue, in §4.5
- CSSKeywordish, in §4.2
- CSSKeywordValue, in §4.2
- CSSKeywordValue(value), in §4.2
- CSSMathClamp, in §4.3.4
- CSSMathClamp(min, val, max), in §4.3.4
- CSSMathInvert, in §4.3.4
- CSSMathInvert(arg), in §4.3.4
- CSSMathMax, in §4.3.4
- CSSMathMax(...args), in §4.3.4
- CSSMathMin, in §4.3.4
- CSSMathMin(...args), in §4.3.4
- CSSMathNegate, in §4.3.4
- CSSMathNegate(arg), in §4.3.4
- CSSMathOperator, in §4.3.4
- CSSMathProduct, in §4.3.4
- CSSMathProduct(...args), in §4.3.4
- CSSMathSum, in §4.3.4
- CSSMathSum(...args), in §4.3.4
- CSSMathValue, in §4.3.4
- CSSMatrixComponent, in §4.4
- CSSMatrixComponent(matrix, options), in §4.4
- CSSMatrixComponentOptions, in §4.4
- CSSNumberish, in §4.3
- CSSNumericArray, in §4.3.4
- CSSNumericBaseType, in §4.3.1
- CSSNumericType, in §4.3.1
- CSSNumericValue, in §4.3.1
- CSSPerspective, in §4.4
- CSSPerspective(length), in §4.4
- CSSRotate, in §4.4
- CSSRotate(angle), in §4.4
- CSSRotate(x, y, z, angle), in §4.4
- CSSScale, in §4.4
- CSSScale(x, y, z), in §4.4
- CSSSkew, in §4.4
- CSSSkew(ax, ay), in §4.4
- CSSSkewX, in §4.4
- CSSSkewX(ax), in §4.4
- CSSSkewY, in §4.4
- CSSSkewY(ay), in §4.4
- CSSStyleValue, in §2
- CSSTransformComponent, in §4.4
- CSSTransformValue, in §4.4
- CSSTransformValue(transforms), in §4.4
- CSSTranslate, in §4.4
- CSSTranslate(x, y, z), in §4.4
- CSSUnitValue, in §4.3.3
- CSSUnitValue(value, unit), in §4.3.3
- CSSUnparsedSegment, in §4.1
- CSSUnparsedValue, in §4.1
- CSSVariableReferenceValue, in §4.1
- CSSVariableReferenceValue(variable, fallback), in §4.1
- custom property name string, in §3
- [[declarations]], in §3
- Declared StylePropertyMap, in §3.2
- deg(value), in §4.3.5
- delete(property), in §3
- div(), in §4.3.1
- div(...values), in §4.3.1
- dpcm(value), in §4.3.5
- dpi(value), in §4.3.5
- dppx(value), in §4.3.5
- em(value), in §4.3.5
- equal numeric value, in §4.3.1
- equals(), in §4.3.1
- equals(...value), in §4.3.1
- equals(...values), in §4.3.1
- ex(value), in §4.3.5
- fallback, in §4.1
- "flex", in §4.3.1
- flex, in §4.3.1
- "frequency", in §4.3.1
- frequency, in §4.3.1
- fr(value), in §4.3.5
- getAll(property), in §3
- get(property), in §3
- grad(value), in §4.3.5
- has(property), in §3
- Hz(value), in §4.3.5
- ic(value), in §4.3.5
- indexed property getter, in §4.3.4
- internal representation, in §1
- in(value), in §4.3.5
- "invert", in §4.3.4
- invert, in §4.3.1
- invert a CSSNumericValue, in §4.3.1
- invert a type, in §4.3.2
- is2D
  - attribute for CSSPerspective, in §4.4
  - attribute for CSSSkew, CSSSkewX, CSSSkewY, in §4.4
  - attribute for CSSTransformComponent, in §4.4
  - attribute for CSSTransformValue, in §4.4
  - dict-member for CSSMatrixComponentOptions, in §4.4
- kHz(value), in §4.3.5
- "length", in §4.3.1
- length
  - attribute for CSSNumericArray, in §4.3.4
  - attribute for CSSPerspective, in §4.4
  - attribute for CSSTransformValue, in §4.4
  - attribute for CSSUnparsedValue, in §4.1
  - dict-member for CSSNumericType, in §4.3.1
- lh(value), in §4.3.5
- list-valued, in §3
- list-valued properties, in §3
- match, in §4.3.2
- match a grammar, in §3
- match the grammar, in §3
- matrix, in §4.4
- "max", in §4.3.4
- max, in §4.3.4
- max(), in §4.3.1
- max(...values), in §4.3.1
- "min", in §4.3.4
- min, in §4.3.4
- min(), in §4.3.1
- min(...values), in §4.3.1
- mm(value), in §4.3.5
- ms(value), in §4.3.5
- mul(), in §4.3.1
- multiplication, in §4.3.2
- multiply, in §4.3.2
- multiply two types, in §4.3.2
- mul(...values), in §4.3.1
- "negate", in §4.3.4
- negate, in §4.3.1
- negate a CSSNumericValue, in §4.3.1
- number(value), in §4.3.5
- operator, in §4.3.4
- parse a CSSStyleValue, in §2
- parseAll(property, cssText), in §2
- parse(cssText), in §4.3.1
- parse(property, cssText), in §2
- pc(value), in §4.3.5
- "percent", in §4.3.1
- percent, in §4.3.1
- percent hint, in §4.3.2
- percentHint, in §4.3.1
- percent(value), in §4.3.5
- "product", in §4.3.4
- product of two unit maps, in §4.3.1
- pt(value), in §4.3.5
- px(value), in §4.3.5
- Q(value), in §4.3.5
- rad(value), in §4.3.5
- rectify a keywordish value, in §4.2
- rectify a numberish value, in §4.3
- rectifying a numberish value, in §4.3
- reification, in §5
- reified as a CSSStyleValue, in §5.2
- reify, in §5
- reify a list of component values, in §5.3
- reify a math expression, in §5.6
- reify an identifier, in §5.5
- reify a numeric value, in §5.6
- reify as a CSSStyleValue, in §5.2
- reify a <transform-function>, in §5.7
- reify a <transform-list>, in §5.7
- reify a var() reference, in §5.4
- rem(value), in §4.3.5
- "resolution", in §4.3.1
- resolution, in §4.3.1
- rlh(value), in §4.3.5
- serialize a CSSKeywordValue, in §6.2
- serialize a CSSMathValue, in §6.4
- serialize a CSSMatrixComponent, in §6.5
- serialize a CSSPerspective, in §6.5
- serialize a CSSRotate, in §6.5
- serialize a CSSScale, in §6.5
- serialize a CSSSkew, in §6.5
- serialize a CSSSkewX, in §6.5
- serialize a CSSSkewY, in §6.5
- serialize a CSSTransformValue, in §6.5
- serialize a CSSTranslate, in §6.5
- serialize a CSSUnitValue, in §6.3
- serialize a CSSUnparsedValue, in §6.1
- serialize a CSSVariableReferenceValue, in §6.1
- set(property), in §3
- set(property, ...values), in §3
- single-valued, in §3
- single-valued properties, in §3
- size
  - attribute for StylePropertyMapReadOnly, in §3
  - attribute for StylePropertyMapReadonly, StylePropertyMap, in §3
- stringification behavior
  - dfn for CSSStyleValue, in §2
  - dfn for CSSTransformComponent, in §4.4
- styleMap, in §3.2
- StylePropertyMap, in §3
- StylePropertyMapReadOnly, in §3
- sub(), in §4.3.1
- subdivide into iterations, in §2
- sub(...values), in §4.3.1
- "sum", in §4.3.4
- sum value, in §4.3.1
- s(value), in §4.3.5
- "time", in §4.3.1
- time, in §4.3.1
- [[tokens]], in §4.1
- toMatrix()
  - method for CSSTransformComponent, in §4.4
  - method for CSSTransformValue, in §4.4
- toSum(), in §4.3.1
- toSum(...units), in §4.3.1
- to(unit), in §4.3.1
- turn(value), in §4.3.5
- type, in §4.3.2
- type(), in §4.3.1
- type of a CSSMathValue, in §4.3.4
- type of a CSSUnitValue, in §4.3.3
- unit, in §4.3.3
- unit map, in §4.3.1
- val, in §4.3.4
- valid CSS property, in §3
- value
  - attribute for CSSKeywordValue, in §4.2
  - attribute for CSSMathInvert, in §4.3.4
  - attribute for CSSMathNegate, in §4.3.4
  - attribute for CSSUnitValue, in §4.3.3
  - dfn for sum value, in §4.3.1
- [[values]], in §4.4
- values
  - attribute for CSSMathMax, in §4.3.4
  - attribute for CSSMathMin, in §4.3.4
  - attribute for CSSMathProduct, in §4.3.4
  - attribute for CSSMathSum, in §4.3.4
- variable, in §4.1
- vb(value), in §4.3.5
- vh(value), in §4.3.5
- vi(value), in §4.3.5
- vmax(value), in §4.3.5
- vmin(value), in §4.3.5
- vw(value), in §4.3.5
- x
  - attribute for CSSRotate, in §4.4
  - attribute for CSSScale, in §4.4
  - attribute for CSSTranslate, in §4.4
- y
  - attribute for CSSRotate, in §4.4
  - attribute for CSSScale, in §4.4
  - attribute for CSSTranslate, in §4.4
- z
  - attribute for CSSRotate, in §4.4
  - attribute for CSSScale, in §4.4
  - attribute for CSSTranslate, in §4.4

https://drafts.fxtf.org/compositing-2/#propdef-background-blend-mode Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/compositing-2/#propdef-mix Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/compositing-2/#propdef-isolation Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/compositing-2/#propdef-mix-blend-mode Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#typedef-overflow-position Referenced in:

- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-align-3/#typedef-self-position Referenced in:

- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-align-3/#propdef-align-content Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-align-items Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-align-self Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-column-gap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-gap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-grid-column-gap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-grid-gap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-grid-row-gap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-justify-content Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-justify-items Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-justify-self Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-place-content Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-place-items Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-place-self Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-align-3/#propdef-row-gap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-animations-1/#propdef-animation Referenced in:

- 3. The StylePropertyMap

https://drafts.csswg.org/css-animations-2/#propdef-animation-composition Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-background Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-background-attachment Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-background-clip Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-background-color Referenced in:

- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-backgrounds-3/#propdef-background-image Referenced in:

- 3. The StylePropertyMap (2)
- 4.5. CSSImageValue objects (2)
- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-background-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-background-repeat Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-bottom Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-bottom-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-bottom-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-bottom-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-color Referenced in:

- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-image Referenced in:

- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-image-outset Referenced in:

- 6.7. Serialization from CSSOM Values (2)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-image-repeat Referenced in:

- 6.7. Serialization from CSSOM Values (2)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-image-slice Referenced in:

- 6.7. Serialization from CSSOM Values (2)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-image-source Referenced in:

- 4.5. CSSImageValue objects
- 6.7. Serialization from CSSOM Values (2)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-image-width Referenced in:

- 6.7. Serialization from CSSOM Values (2) (3)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-left Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-left-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-left-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-left-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-radius Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-right Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-right-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-right-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-right-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-top Referenced in:

- 5.1. Property-specific Rules (2) (3) (4) (5)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-top-color Referenced in:

- 5.1. Property-specific Rules (2) (3) (4) (5) (6)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-top-style Referenced in:

- 5.1. Property-specific Rules (2) (3) (4) (5) (6)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-top-width Referenced in:

- 5.1. Property-specific Rules (2) (3) (4) (5) (6)

https://drafts.csswg.org/css-backgrounds-3/#propdef-border-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-backgrounds-3/#border-image-slice-fill Referenced in:

- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-backgrounds-3/#valdef-border-image-repeat-stretch Referenced in:

- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-box-3/#propdef-margin Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-margin-bottom Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-margin-left Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-margin-right Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-margin-top Referenced in:

- 5.1. Property-specific Rules (2) (3) (4)

https://drafts.csswg.org/css-box-3/#propdef-padding Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-padding-bottom Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-padding-left Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-padding-right Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-box-3/#propdef-padding-top Referenced in:

- 5.1. Property-specific Rules (2) (3) (4)

https://drafts.csswg.org/css-break-3/#propdef-break-after Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-break-3/#propdef-break-before Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-break-3/#propdef-break-inside Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-break-3/#propdef-orphans Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-break-4/#propdef-box-decoration-break Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-break-4/#propdef-widows Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-cascade-4/#propdef-all Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-cascade-4/#computed-value Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects (2) (3) (4)
- 4.5. CSSImageValue objects

https://drafts.csswg.org/css-cascade-4/#shorthand-property Referenced in:

- 3. The StylePropertyMap

https://drafts.csswg.org/css-color-3/#valuea-def-color Referenced in:

- 6.7. Serialization from CSSOM Values (2) (3)

https://drafts.csswg.org/css-color-4/#propdef-color Referenced in:

- 3. The StylePropertyMap
- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-color-4/#valdef-color-currentcolor Referenced in:

- 6.7. Serialization from CSSOM Values (2) (3)

https://drafts.csswg.org/css-color-4/#propdef-opacity Referenced in:

- 4.3. Numeric Values:
- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-color-adjust-1/#propdef-color-adjust Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-contain-1/#propdef-contain Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-content-3/#propdef-bookmark-label Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-content-3/#propdef-bookmark-level Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-content-3/#propdef-bookmark-state Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-content-3/#propdef-content Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-content-3/#propdef-quotes Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-display-3/#propdef-display Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-flex Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-flex-basis Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-flex-direction Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-flex-flow Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-flex-grow Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-flex-shrink Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-flex-wrap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-flexbox-1/#propdef-order Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-3/#absolute-size-value Referenced in:

- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-fonts-3/#relative-size-value Referenced in:

- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-fonts-3/#propdef-font Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-3/#propdef-font-family Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-3/#propdef-font-size Referenced in:

- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-fonts-3/#propdef-font-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-3/#propdef-font-variant Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-3/#propdef-font-weight Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-language-override Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-max-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-min-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-optical-sizing Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-palette Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-size-adjust Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-stretch Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-synthesis Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-variant-alternates Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-variant-emoji Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-fonts-4/#propdef-font-variation-settings Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-gcpm-4/#propdef-copy-into Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#typedef-flex Referenced in:

- 4.3.2. Numeric Value Typing (2)

https://drafts.csswg.org/css-grid-1/#propdef-grid Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-area Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-auto-columns Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-auto-flow Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-auto-rows Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-column Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-column-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-column-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-row Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-row-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-row-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-template Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-template-areas Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-template-columns Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-grid-1/#propdef-grid-template-rows Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-images-4/#funcdef-image Referenced in:

- 4.5. CSSImageValue objects

https://drafts.csswg.org/css-images-4/#propdef-image-resolution Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-images-4/#propdef-object-fit Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-inline-3/#propdef-alignment-baseline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-inline-3/#propdef-baseline-shift Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-inline-3/#propdef-dominant-baseline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-inline-3/#propdef-vertical-align Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-line-grid-1/#propdef-box-snap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-line-grid-1/#propdef-line-grid Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-line-grid-1/#propdef-line-snap Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-counter-increment Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-counter-reset Referenced in:

- 2. CSSStyleValue objects
- 3. The StylePropertyMap
- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-counter-set Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-list-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-list-style-image Referenced in:

- 4.5. CSSImageValue objects
- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-list-style-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-list-style-type Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-lists-3/#propdef-marker-side Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-block-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-end-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-end-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-end-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-start Referenced in:

- 5.1. Property-specific Rules (2) (3)

https://drafts.csswg.org/css-logical-1/#propdef-border-block-start-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-start-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-start-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-block-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-end-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-end-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-end-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-start-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-start-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-start-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-border-inline-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inline-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inset Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inset-block Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inset-block-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inset-block-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inset-inline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inset-inline-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-inset-inline-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-margin-block Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-margin-block-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-margin-block-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-margin-inline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-margin-inline-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-margin-inline-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-max-block-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-max-inline-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-min-block-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-min-inline-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-padding-block Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-padding-block-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-padding-block-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-padding-inline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-padding-inline-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-logical-1/#propdef-padding-inline-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-clip Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-clip-path Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-clip-rule Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-border Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-border-mode Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-border-outset Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-border-repeat Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-border-slice Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-border-source Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-border-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-clip Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-composite Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-image Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-mode Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-origin Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-repeat Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/css-masking-1/#propdef-mask-type Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-multicol-2/#propdef-column-span Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-overflow-3/#propdef-overflow Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-overflow-3/#propdef-overflow-x Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-overflow-3/#propdef-overflow-y Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-overflow-4/#propdef-continue Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-overflow-4/#propdef-max-lines Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-overflow-4/#propdef-scrollbar-gutter Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-overflow-4/#propdef-text-overflow Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-page-3/#propdef-page Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-page-floats-3/#propdef-float-defer Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-position-3/#valdef-top-auto Referenced in:

- 3. The StylePropertyMap (2)
- 6.7. Serialization from CSSOM Values (2) (3) (4)

https://drafts.csswg.org/css-position-3/#propdef-bottom Referenced in:

- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-position-3/#propdef-left Referenced in:

- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://www.w3.org/TR/css3-positioning/#propdef-offset-after Referenced in:

- 5.1. Property-specific Rules

https://www.w3.org/TR/css3-positioning/#propdef-offset-before Referenced in:

- 5.1. Property-specific Rules

https://www.w3.org/TR/css3-positioning/#propdef-offset-end Referenced in:

- 5.1. Property-specific Rules

https://www.w3.org/TR/css3-positioning/#propdef-offset-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-position-3/#propdef-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-position-3/#propdef-right Referenced in:

- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-position-3/#propdef-top Referenced in:

- 5.1. Property-specific Rules
- 6.7. Serialization from CSSOM Values

https://drafts.csswg.org/css-position-3/#propdef-z-index Referenced in:

- 4.3. Numeric Values:
- 5.1. Property-specific Rules

https://drafts.csswg.org/css-preslev-1/#presentation-level Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-regions-1/#propdef-region-fragment Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-rhythm-1/#propdef-block-step Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-rhythm-1/#propdef-block-step-align Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-rhythm-1/#propdef-block-step-insert Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-rhythm-1/#propdef-block-step-round Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-rhythm-1/#propdef-block-step-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-rhythm-1/#propdef-line-height-step Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-round-display-1/#propdef-border-boundary Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ruby-1/#propdef-ruby-align Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ruby-1/#propdef-ruby-merge Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ruby-1/#propdef-ruby-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-anchoring/#propdef-overflow-anchor Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-block Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-block-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-block-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-bottom Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-inline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-inline-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-inline-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-left Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-right Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-margin-top Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-block Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-block-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-block-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-bottom Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-inline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-inline-end Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-inline-start Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-left Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-right Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-padding-top Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-snap-align Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-snap-stop Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-scroll-snap-1/#propdef-scroll-snap-type Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-shapes-1/#propdef-shape-margin Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-shapes-2/#propdef-shape-inside Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-shapes-2/#propdef-shape-padding Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-size-adjust-1/#propdef-text-size-adjust Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-sizing-3/#propdef-box-sizing Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-sizing-3/#propdef-max-height Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-sizing-3/#propdef-max-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-sizing-3/#propdef-min-height Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-sizing-3/#propdef-min-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-syntax-3/#typedef-dimension-token Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

https://drafts.csswg.org/css-syntax-3/#typedef-number-token Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

https://drafts.csswg.org/css-syntax-3/#typedef-percentage-token Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

https://drafts.csswg.org/css-syntax-3/#component-value Referenced in:

- 3. The StylePropertyMap
- 5.3. Raw CSS tokens: properties with var() references (2)

https://drafts.csswg.org/css-syntax-3/#identifier Referenced in:

- 3. The StylePropertyMap
- 4.2. CSSKeywordValue objects
- 5.5. Identifier Values (2) (3)

https://drafts.csswg.org/css-syntax-3/#css-parse-something-according-to-a-css-grammar Referenced in:

- 2. CSSStyleValue objects

https://drafts.csswg.org/css-syntax-3/#parse-a-component-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

https://drafts.csswg.org/css-tables-3/#propdef-border-collapse Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-tables-3/#propdef-caption-side Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-tables-3/#propdef-empty-cells Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-tables-3/#propdef-table-layout Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-3/#propdef-letter-spacing Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-3/#propdef-text-align Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-3/#propdef-text-indent Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-3/#propdef-text-transform Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-3/#propdef-word-spacing Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-4/#propdef-white-space Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-decor-3/#propdef-text-decoration Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-decor-4/#propdef-text-decoration-skip Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-decor-4/#propdef-text-decoration-skip-ink Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-decor-4/#propdef-text-decoration-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-decor-4/#propdef-text-emphasis-skip Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-text-decor-4/#propdef-text-underline-offset Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-1/#typedef-transform-function Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values (2) (3)

https://drafts.csswg.org/css-transforms-1/#typedef-transform-list Referenced in:

- 3. The StylePropertyMap
- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values (2) (3)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-matrix Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-rotate Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-scale Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-scalex Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-scaley Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-skew Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-skewx Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-skewy Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-1/#propdef-transform Referenced in:

- 4.4. CSSTransformValue objects

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-translate Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-translatex Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-1/#funcdef-transform-translatey Referenced in:

- 5.7. <transform-list> and <transform-function> values (2)

https://drafts.csswg.org/css-transforms-2/#propdef-backface-visibility Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-2/#funcdef-matrix3d Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#propdef-perspective Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-2/#funcdef-perspective Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#propdef-perspective-origin Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-2/#propdef-rotate Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-2/#funcdef-rotate3d Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#funcdef-rotatex Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#funcdef-rotatey Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#funcdef-rotatez Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#propdef-scale Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-2/#funcdef-scale3d Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#funcdef-scalez Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#propdef-transform-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-2/#propdef-translate Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transforms-2/#funcdef-translate3d Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transforms-2/#funcdef-translatez Referenced in:

- 5.7. <transform-list> and <transform-function> values

https://drafts.csswg.org/css-transitions-1/#propdef-transition Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transitions-1/#propdef-transition-delay Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transitions-1/#propdef-transition-duration Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transitions-1/#propdef-transition-property Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-transitions-1/#propdef-transition-timing-function Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-appearance Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-caret Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-caret-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-caret-shape Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-cursor Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-nav-down Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-nav-left Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-nav-right Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-nav-up Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-outline Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-outline-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-outline-offset Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-outline-style Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-outline-width Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-resize Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-ui-4/#propdef-user-select Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-values-3/#angle-value Referenced in:

- 4.3.2. Numeric Value Typing (2)
- 4.4. CSSTransformValue objects (2) (3) (4) (5)
- 5.1. Property-specific Rules

https://drafts.csswg.org/css-values-3/#length-value Referenced in:

- 4.3.2. Numeric Value Typing (2) (3) (4)
- 4.4. CSSTransformValue objects (2) (3)
- 5.1. Property-specific Rules (2) (3)
- 6.7. Serialization from CSSOM Values (2) (3) (4) (5) (6) (7) (8)

https://drafts.csswg.org/css-values-3/#typedef-number-percentage Referenced in:

- 4.3.2. Numeric Value Typing

https://drafts.csswg.org/css-values-3/#number-value Referenced in:

- 4.3. Numeric Values:
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.3.2. Numeric Value Typing
- 4.4. CSSTransformValue objects (2)
- 5.1. Property-specific Rules
- 5.6. <number>, <percentage>, and <dimension> values (2) (3)
- 6.3. CSSUnitValue Serialization
- 6.7. Serialization from CSSOM Values (2)

https://drafts.csswg.org/css-values-3/#percentage-value Referenced in:

- 4.3. Numeric Values:
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.3.2. Numeric Value Typing (2) (3)
- 5.1. Property-specific Rules (2) (3)
- 5.6. <number>, <percentage>, and <dimension> values (2) (3)
- 6.7. Serialization from CSSOM Values (2) (3) (4) (5)

https://drafts.csswg.org/css-values-3/#resolution-value Referenced in:

- 4.3.2. Numeric Value Typing (2)

https://drafts.csswg.org/css-values-3/#url-value Referenced in:

- 3. The StylePropertyMap
- 5.8. <url> (and subtype) Values

https://drafts.csswg.org/css-values-4/#typedef-angle-percentage Referenced in:

- 4.3.2. Numeric Value Typing (2)

https://drafts.csswg.org/css-values-4/#identifier-value Referenced in:

- 5.4. var() References

https://drafts.csswg.org/css-values-4/#typedef-dimension Referenced in:

- 4.3. Numeric Values:
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 5.6. <number>, <percentage>, and <dimension> values (2) (3) (4)

https://drafts.csswg.org/css-values-4/#frequency-value Referenced in:

- 4.3.2. Numeric Value Typing (2)

https://drafts.csswg.org/css-values-4/#typedef-length-percentage Referenced in:

- 4.3.2. Numeric Value Typing (2) (3)
- 4.4. CSSTransformValue objects

https://drafts.csswg.org/css-values-4/#typedef-time-percentage Referenced in:

- 4.3.2. Numeric Value Typing

https://drafts.csswg.org/css-values-4/#time-value Referenced in:

- 4.3.2. Numeric Value Typing (2)

https://drafts.csswg.org/css-values-4/#funcdef-calc Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects
- 5.6. <number>, <percentage>, and <dimension> values (2)

https://drafts.csswg.org/css-values-4/#canonical-unit Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 5.6. <number>, <percentage>, and <dimension> values (2)

https://drafts.csswg.org/css-values-4/#compatible-units Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 4.3.3. Value + Unit: CSSUnitValue objects
- 4.4. CSSTransformValue objects

https://drafts.csswg.org/css-values-4/#em Referenced in:

- 5.6. <number>, <percentage>, and <dimension> values

https://drafts.csswg.org/css-values-4/#css-identifier Referenced in:

- 3. The StylePropertyMap (2) (3)

https://drafts.csswg.org/css-values-4/#in Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

https://drafts.csswg.org/css-values-4/#math-function Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.3.2. Numeric Value Typing
- 5.6. <number>, <percentage>, and <dimension> values

https://drafts.csswg.org/css-values-4/#funcdef-max Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects
- 5.6. <number>, <percentage>, and <dimension> values

https://drafts.csswg.org/css-values-4/#funcdef-min Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects
- 5.6. <number>, <percentage>, and <dimension> values

https://drafts.csswg.org/css-values-4/#percentage Referenced in:

- 4.4. CSSTransformValue objects

https://drafts.csswg.org/css-values-4/#px Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)
- 4.4. CSSTransformValue objects (2)
- 5.6. <number>, <percentage>, and <dimension> values

https://drafts.csswg.org/css-values-4/#relative-length Referenced in:

- 4.4. CSSTransformValue objects

https://drafts.csswg.org/css-values-4/#funcdef-url Referenced in:

- 4.5. CSSImageValue objects
- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-variables-1/#typedef-custom-property-name Referenced in:

- 3. The StylePropertyMap

https://drafts.csswg.org/css-variables-1/#custom-property Referenced in:

- 3. The StylePropertyMap (2)
- 3.1. Computed StylePropertyMapReadOnly objects (2)
- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-variables-1/#funcdef-var Referenced in:

- 3. The StylePropertyMap (2) (3) (4) (5)
- 5. CSSStyleValue Reification
- 5.3. Raw CSS tokens: properties with var() references (2) (3)
- 5.4. var() References (2) (3)

https://drafts.csswg.org/css-will-change-1/#propdef-will-change Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-writing-modes-3/#propdef-direction Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-writing-modes-3/#propdef-unicode-bidi Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-writing-modes-4/#propdef-glyph-orientation-vertical Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-writing-modes-4/#propdef-text-combine-upright Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-writing-modes-4/#propdef-text-orientation Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-writing-modes-4/#propdef-writing-mode Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-azimuth Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/tables.html#propdef-border-spacing Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/visuren.html#propdef-clear Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-elevation Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/visuren.html#propdef-float Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/visudet.html#propdef-height Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/visudet.html#propdef-line-height Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/page.html#propdef-page-break-after Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/page.html#propdef-page-break-before Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/page.html#propdef-page-break-inside Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-pitch Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-pitch-range Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-play-during Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-richness Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-speak-header Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-speak-numeral Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-speak-punctuation Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-speech-rate Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-stress Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/visufx.html#propdef-visibility Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/aural.html#propdef-volume Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css2/visudet.html#propdef-width Referenced in:

- 3. The StylePropertyMap
- 3.1. Computed StylePropertyMapReadOnly objects
- 5.1. Property-specific Rules (2)

https://drafts.csswg.org/css-images-3/#typedef-image Referenced in:

- 3. The StylePropertyMap
- 4.5. CSSImageValue objects (2)

https://drafts.csswg.org/css-images-3/#propdef-image-rendering Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#cue Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#cue-after Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#cue-before Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#pause Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#pause-after Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#pause-before Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#rest Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#rest-after Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#rest-before Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#speak Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#speak-as Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-balance Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-duration Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-family Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-pitch Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-range Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-rate Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-stress Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/css-speech-1/#voice-volume Referenced in:

- 5.1. Property-specific Rules

https://drafts.csswg.org/cssom-1/#namespacedef-css Referenced in:

- 4.3.5. Numeric Factory Functions

https://drafts.csswg.org/cssom-1/#cssstyledeclaration Referenced in:

- 3. The StylePropertyMap

https://drafts.csswg.org/cssom-1/#cssstylerule Referenced in:

- 3.2. Declared & Inline StylePropertyMap objects (2) (3) (4)

https://drafts.csswg.org/cssom-1/#elementcssinlinestyle Referenced in:

- 3.2. Declared & Inline StylePropertyMap objects (2)

https://drafts.csswg.org/cssom-1/#css-declaration-block Referenced in:

- 3. The StylePropertyMap (2) (3)

https://drafts.csswg.org/cssom-1/#cssstyledeclaration-declarations Referenced in:

- 3. The StylePropertyMap (2)

https://drafts.csswg.org/cssom-1/#dom-window-getcomputedstyle Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects (2) (3) (4)

https://drafts.csswg.org/cssom-1/#concept-css-style-sheet-origin-clean-flag Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects

https://drafts.csswg.org/cssom-1/#resolved-value Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects

https://drafts.csswg.org/cssom-view-1/#propdef-scroll-behavior Referenced in:

- 5.1. Property-specific Rules

https://dom.spec.whatwg.org/#element Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects (2) (3) (4)

https://drafts.fxtf.org/fill-stroke-3/#propdef-fill-break Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-fill-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-fill-image Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-fill-origin Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-fill-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-fill-repeat Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-fill-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-align Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-break Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-color Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-dash-corner Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-dash-justify Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-image Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-origin Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-repeat Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/fill-stroke-3/#propdef-stroke-size Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/filter-effects-2/#propdef-backdrop-filter Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/geometry-1/#dommatrix Referenced in:

- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6)

https://drafts.fxtf.org/geometry-1/#dommatrixreadonly Referenced in:

- 4.4. CSSTransformValue objects

https://drafts.fxtf.org/geometry-1/#dom-dommatrixreadonly-is2d Referenced in:

- 4.4. CSSTransformValue objects (2) (3)

https://drafts.fxtf.org/geometry-1/#dommatrixreadonly-stringification-behavior Referenced in:

- 6.5. CSSTransformValue and CSSTransformComponent Serialization

https://html.spec.whatwg.org/multipage/dom.html#htmlelement Referenced in:

- 3.2. Declared & Inline StylePropertyMap objects

https://html.spec.whatwg.org/multipage/semantics.html#the-style-element Referenced in:

- 4.5. CSSImageValue objects

https://infra.spec.whatwg.org/#list-append Referenced in:

- 3. The StylePropertyMap (2)
- 4.1. CSSUnparsedValue objects
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 4.4. CSSTransformValue objects

https://infra.spec.whatwg.org/#ascii-lowercase Referenced in:

- 2. CSSStyleValue objects
- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7) (8)

https://infra.spec.whatwg.org/#code-point Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

https://infra.spec.whatwg.org/#map-exists Referenced in:

- 3. The StylePropertyMap (2) (3) (4) (5) (6)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.3.2. Numeric Value Typing (2) (3) (4) (5) (6) (7) (8) (9)

https://infra.spec.whatwg.org/#list-empty Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)
- 6.7. Serialization from CSSOM Values

https://infra.spec.whatwg.org/#map-entry Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7)
- 4.3.2. Numeric Value Typing (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13)

https://infra.spec.whatwg.org/#map-exists Referenced in:

- 3. The StylePropertyMap (2) (3) (4) (5) (6)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.3.2. Numeric Value Typing (2) (3) (4) (5) (6) (7) (8) (9)

https://infra.spec.whatwg.org/#map-iterate Referenced in:

- 3. The StylePropertyMap
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)
- 4.3.2. Numeric Value Typing (2)

https://infra.spec.whatwg.org/#list-is-empty Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects
- 4.4. CSSTransformValue objects

https://infra.spec.whatwg.org/#list-item Referenced in:

- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23) (24) (25) (26) (27) (28) (29) (30) (31) (32) (33) (34) (35) (36) (37) (38) (39) (40) (41) (42) (43) (44) (45) (46) (47) (48) (49) (50) (51) (52) (53) (54) (55) (56) (57)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5)
- 6.4. CSSMathValue Serialization (2)
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

https://infra.spec.whatwg.org/#map-key Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

https://infra.spec.whatwg.org/#list Referenced in:

- 2. CSSStyleValue objects (2)
- 3. The StylePropertyMap (2) (3) (4) (5)
- 4.1. CSSUnparsedValue objects
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5)
- 4.4. CSSTransformValue objects (2)
- 5.3. Raw CSS tokens: properties with var() references
- 6.7. Serialization from CSSOM Values

https://infra.spec.whatwg.org/#ordered-map Referenced in:

- 3. The StylePropertyMap (2) (3)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.3.2. Numeric Value Typing (2) (3) (4)

https://infra.spec.whatwg.org/#ordered-map Referenced in:

- 3. The StylePropertyMap (2) (3)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.3.2. Numeric Value Typing (2) (3) (4)

https://infra.spec.whatwg.org/#list-prepend Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)

https://infra.spec.whatwg.org/#map-remove Referenced in:

- 3. The StylePropertyMap (2) (3)

https://infra.spec.whatwg.org/#map-set Referenced in:

- 3. The StylePropertyMap

https://infra.spec.whatwg.org/#map-size Referenced in:

- 3. The StylePropertyMap

https://infra.spec.whatwg.org/#string Referenced in:

- 2. CSSStyleValue objects (2)
- 2.1. Direct CSSStyleValue Objects
- 3. The StylePropertyMap (2) (3) (4) (5) (6)
- 6.1. CSSUnparsedValue Serialization
- 6.4. CSSMathValue Serialization
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2) (3)

https://infra.spec.whatwg.org/#tuple Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

https://infra.spec.whatwg.org/#map-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 4.3.2. Numeric Value Typing
- 4.3.4. Complex Numeric Values: CSSMathValue objects

https://drafts.fxtf.org/motion-1/#propdef-offset Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/motion-1/#propdef-offset-anchor Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/motion-1/#propdef-offset-distance Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/motion-1/#propdef-offset-path Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/motion-1/#propdef-offset-position Referenced in:

- 5.1. Property-specific Rules

https://drafts.fxtf.org/motion-1/#propdef-offset-rotate Referenced in:

- 5.1. Property-specific Rules

https://www.w3.org/TR/SVG11/painting.html#ColorRenderingProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#ColorInterpolationProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/geometry.html#CxProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/geometry.html#CyProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/paths.html#DProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#FillProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#FillOpacityProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#FillRuleProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#MarkerProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#MarkerEndProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#MarkerMidProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#MarkerStartProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#PaintOrderProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/interact.html#PointerEventsProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/geometry.html#RProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/geometry.html#RxProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/geometry.html#RyProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#ShapeRenderingProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/text.html#ShapesubtractProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/pservers.html#StopColorProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/pservers.html#StopOpacityProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeDasharrayProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeDashoffsetProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeLinecapProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeLinejoinProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeMiterlimitProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeOpacityProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#StrokeWidthProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/text.html#TextAnchorProperty Referenced in:

- 5.1. Property-specific Rules

https://www.w3.org/TR/svg2/text.html#TextDecorationFillProperty Referenced in:

- 5.1. Property-specific Rules

https://www.w3.org/TR/svg2/text.html#TextDecorationStrokeProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/painting.html#TextRenderingProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/coords.html#VectorEffectProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/geometry.html#XProperty Referenced in:

- 5.1. Property-specific Rules

https://svgwg.org/svg2-draft/geometry.html#YProperty Referenced in:

- 5.1. Property-specific Rules

https://heycam.github.io/webidl/#idl-DOMString Referenced in:

- 4.2. CSSKeywordValue objects (2)

https://heycam.github.io/webidl/#Exposed Referenced in:

- 2. CSSStyleValue objects (2) (3)
- 3. The StylePropertyMap (2)
- 4.1. CSSUnparsedValue objects (2)
- 4.2. CSSKeywordValue objects
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)
- 4.3.3. Value + Unit: CSSUnitValue objects
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5) (6) (7) (8) (9)
- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10)
- 4.5. CSSImageValue objects

https://heycam.github.io/webidl/#exceptiondef-rangeerror Referenced in:

- 4.1. CSSUnparsedValue objects
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.4. CSSTransformValue objects

https://heycam.github.io/webidl/#SameObject Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects
- 3.2. Declared & Inline StylePropertyMap objects (2)

https://heycam.github.io/webidl/#syntaxerror Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 4.3.4. Complex Numeric Values: CSSMathValue objects

https://heycam.github.io/webidl/#exceptiondef-typeerror Referenced in:

- 2. CSSStyleValue objects (2) (3)
- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15)
- 4.1. CSSUnparsedValue objects (2)
- 4.2. CSSKeywordValue objects (2)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10)
- 4.3.3. Value + Unit: CSSUnitValue objects
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)
- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12)

https://heycam.github.io/webidl/#idl-USVString Referenced in:

- 2. CSSStyleValue objects (2) (3) (4)
- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7) (8) (9) (10)
- 4.1. CSSUnparsedValue objects (2) (3) (4)
- 4.2. CSSKeywordValue objects (2) (3)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 4.3.3. Value + Unit: CSSUnitValue objects (2)
- 6.1. CSSUnparsedValue Serialization

https://heycam.github.io/webidl/#idl-boolean Referenced in:

- 3. The StylePropertyMap
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.4. CSSTransformValue objects (2) (3)

https://heycam.github.io/webidl/#dfn-determine-the-value-of-an-indexed-property Referenced in:

- 4.1. CSSUnparsedValue objects
- 4.4. CSSTransformValue objects

https://heycam.github.io/webidl/#idl-double Referenced in:

- 4.3. Numeric Values: (2) (3)
- 4.3.3. Value + Unit: CSSUnitValue objects (2)
- 4.3.5. Numeric Factory Functions (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23) (24) (25) (26) (27) (28) (29) (30) (31) (32) (33) (34)

https://heycam.github.io/webidl/#dfn-indexed-property-getter Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects

https://heycam.github.io/webidl/#idl-long Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7)

https://heycam.github.io/webidl/#dfn-set-the-value-of-a-new-indexed-property Referenced in:

- 4.1. CSSUnparsedValue objects
- 4.4. CSSTransformValue objects

https://heycam.github.io/webidl/#dfn-set-the-value-of-an-existing-indexed-property Referenced in:

- 4.1. CSSUnparsedValue objects
- 4.4. CSSTransformValue objects

https://heycam.github.io/webidl/#dfn-supported-property-indices Referenced in:

- 4.1. CSSUnparsedValue objects
- 4.4. CSSTransformValue objects

https://heycam.github.io/webidl/#dfn-throw Referenced in:

- 2. CSSStyleValue objects (2)
- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14)
- 4.1. CSSUnparsedValue objects (2) (3)
- 4.2. CSSKeywordValue objects (2)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15)
- 4.3.3. Value + Unit: CSSUnitValue objects
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)
- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13)

https://heycam.github.io/webidl/#idl-unsigned-long Referenced in:

- 3. The StylePropertyMap
- 4.1. CSSUnparsedValue objects (2) (3)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)
- 4.4. CSSTransformValue objects (2) (3)

https://heycam.github.io/webidl/#dfn-value-pairs-to-iterate-over Referenced in:

- 3. The StylePropertyMap

### Terms defined by reference

- [compositing-2] defines the following terms:
  - background-blend-mode
  - globalcompositeoperation
  - isolation
  - mix-blend-mode
- [css-align-3] defines the following terms:
  - <overflow-position>
  - <self-position>
  - align-content
  - align-items
  - align-self
  - column-gap
  - gap
  - grid-column-gap
  - grid-gap
  - grid-row-gap
  - justify-content
  - justify-items
  - justify-self
  - place-content
  - place-items
  - place-self
  - row-gap
- [css-animations-1] defines the following terms:
  - animation
- [css-animations-2] defines the following terms:
  - animation-composition
- [css-backgrounds-3] defines the following terms:
  - background
  - background-attachment
  - background-clip
  - background-color
  - background-image
  - background-position
  - background-repeat
  - border
  - border-bottom
  - border-bottom-color
  - border-bottom-style
  - border-bottom-width
  - border-color
  - border-image
  - border-image-outset
  - border-image-repeat
  - border-image-slice
  - border-image-source
  - border-image-width
  - border-left
  - border-left-color
  - border-left-style
  - border-left-width
  - border-radius
  - border-right
  - border-right-color
  - border-right-style
  - border-right-width
  - border-style
  - border-top
  - border-top-color
  - border-top-style
  - border-top-width
  - border-width
  - fill
  - stretch
- [css-box-3] defines the following terms:
  - margin
  - margin-bottom
  - margin-left
  - margin-right
  - margin-top
  - padding
  - padding-bottom
  - padding-left
  - padding-right
  - padding-top
- [css-break-3] defines the following terms:
  - break-after
  - break-before
  - break-inside
  - orphans
- [css-break-4] defines the following terms:
  - box-decoration-break
  - widows
- [css-cascade-4] defines the following terms:
  - all
  - computed value
  - shorthand property
- [css-color-3] defines the following terms:
  - <color>
- [css-color-4] defines the following terms:
  - color
  - currentcolor
  - opacity
- [css-color-adjust-1] defines the following terms:
  - color-adjust
- [css-contain-1] defines the following terms:
  - contain
- [css-content-3] defines the following terms:
  - bookmark-label
  - bookmark-level
  - bookmark-state
  - content
  - quotes
- [css-display-3] defines the following terms:
  - display
- [css-flexbox-1] defines the following terms:
  - flex
  - flex-basis
  - flex-direction
  - flex-flow
  - flex-grow
  - flex-shrink
  - flex-wrap
  - order
- [css-fonts-3] defines the following terms:
  - <absolute-size>
  - <relative-size>
  - font
  - font-family
  - font-size
  - font-style
  - font-variant
  - font-weight
- [css-fonts-4] defines the following terms:
  - font-language-override
  - font-max-size
  - font-min-size
  - font-optical-sizing
  - font-palette
  - font-size-adjust
  - font-stretch
  - font-synthesis
  - font-variant-alternates
  - font-variant-emoji
  - font-variation-settings
- [css-gcpm-4] defines the following terms:
  - copy-into
- [css-grid-1] defines the following terms:
  - <flex>
  - grid
  - grid-area
  - grid-auto-columns
  - grid-auto-flow
  - grid-auto-rows
  - grid-column
  - grid-column-end
  - grid-column-start
  - grid-row
  - grid-row-end
  - grid-row-start
  - grid-template
  - grid-template-areas
  - grid-template-columns
  - grid-template-rows
- [css-images-4] defines the following terms:
  - image()
  - image-resolution
  - object-fit
- [css-inline-3] defines the following terms:
  - alignment-baseline
  - baseline-shift
  - dominant-baseline
  - vertical-align
- [css-line-grid-1] defines the following terms:
  - box-snap
  - line-grid
  - line-snap
- [css-lists-3] defines the following terms:
  - counter-increment
  - counter-reset
  - counter-set
  - list-style
  - list-style-image
  - list-style-position
  - list-style-type
  - marker-side
- [css-logical-1] defines the following terms:
  - block-size
  - border-block
  - border-block-color
  - border-block-end
  - border-block-end-color
  - border-block-end-style
  - border-block-end-width
  - border-block-start
  - border-block-start-color
  - border-block-start-style
  - border-block-start-width
  - border-block-style
  - border-block-width
  - border-inline
  - border-inline-color
  - border-inline-end
  - border-inline-end-color
  - border-inline-end-style
  - border-inline-end-width
  - border-inline-start
  - border-inline-start-color
  - border-inline-start-style
  - border-inline-start-width
  - border-inline-style
  - border-inline-width
  - inline-size
  - inset
  - inset-block
  - inset-block-end
  - inset-block-start
  - inset-inline
  - inset-inline-end
  - inset-inline-start
  - margin-block
  - margin-block-end
  - margin-block-start
  - margin-inline
  - margin-inline-end
  - margin-inline-start
  - max-block-size
  - max-inline-size
  - min-block-size
  - min-inline-size
  - padding-block
  - padding-block-end
  - padding-block-start
  - padding-inline
  - padding-inline-end
  - padding-inline-start
- [css-masking-1] defines the following terms:
  - clip
  - clip-path
  - clip-rule
  - mask
  - mask-border
  - mask-border-mode
  - mask-border-outset
  - mask-border-repeat
  - mask-border-slice
  - mask-border-source
  - mask-border-width
  - mask-clip
  - mask-composite
  - mask-image
  - mask-mode
  - mask-origin
  - mask-position
  - mask-repeat
  - mask-size
  - mask-type
- [css-multicol-2] defines the following terms:
  - column-span
- [css-overflow-3] defines the following terms:
  - overflow
  - overflow-x
  - overflow-y
- [css-overflow-4] defines the following terms:
  - continue
  - max-lines
  - scrollbar-gutter
  - text-overflow
- [css-page-3] defines the following terms:
  - page
- [css-page-floats-3] defines the following terms:
  - float-defer
- [css-position-3] defines the following terms:
  - auto
  - bottom
  - left
  - offset-after
  - offset-before
  - offset-end
  - offset-start
  - position
  - right
  - top
  - z-index
- [css-preslev-1] defines the following terms:
  - presentation-level
- [css-regions-1] defines the following terms:
  - region-fragment
- [css-rhythm-1] defines the following terms:
  - block-step
  - block-step-align
  - block-step-insert
  - block-step-round
  - block-step-size
  - line-height-step
- [css-round-display-1] defines the following terms:
  - border-boundary
- [css-ruby-1] defines the following terms:
  - ruby-align
  - ruby-merge
  - ruby-position
- [css-scroll-anchoring-1] defines the following terms:
  - overflow-anchor
- [css-scroll-snap-1] defines the following terms:
  - scroll-margin
  - scroll-margin-block
  - scroll-margin-block-end
  - scroll-margin-block-start
  - scroll-margin-bottom
  - scroll-margin-inline
  - scroll-margin-inline-end
  - scroll-margin-inline-start
  - scroll-margin-left
  - scroll-margin-right
  - scroll-margin-top
  - scroll-padding
  - scroll-padding-block
  - scroll-padding-block-end
  - scroll-padding-block-start
  - scroll-padding-bottom
  - scroll-padding-inline
  - scroll-padding-inline-end
  - scroll-padding-inline-start
  - scroll-padding-left
  - scroll-padding-right
  - scroll-padding-top
  - scroll-snap-align
  - scroll-snap-stop
  - scroll-snap-type
- [css-shapes-1] defines the following terms:
  - shape-margin
- [css-shapes-2] defines the following terms:
  - shape-inside
  - shape-padding
- [css-size-adjust-1] defines the following terms:
  - text-size-adjust
- [css-sizing-3] defines the following terms:
  - box-sizing
  - max-height
  - max-width
  - min-height
  - min-width
- [css-syntax-3] defines the following terms:
  - <dimension-token>
  - <number-token>
  - <percentage-token>
  - component value
  - identifier
  - parse
  - parse a component value
- [css-tables-3] defines the following terms:
  - border-collapse
  - caption-side
  - empty-cells
  - table-layout
- [css-text-3] defines the following terms:
  - letter-spacing
  - text-align
  - text-indent
  - text-transform
  - word-spacing
- [css-text-4] defines the following terms:
  - white-space
- [css-text-decor-3] defines the following terms:
  - text-decoration
- [css-text-decor-4] defines the following terms:
  - text-decoration-skip
  - text-decoration-skip-ink
  - text-decoration-width
  - text-emphasis-skip
  - text-underline-offset
- [css-transforms-1] defines the following terms:
  - <transform-function>
  - <transform-list>
  - matrix()
  - rotate()
  - scale()
  - scalex()
  - scaley()
  - skew()
  - skewx()
  - skewy()
  - transform
  - translate()
  - translatex()
  - translatey()
- [css-transforms-2] defines the following terms:
  - backface-visibility
  - matrix3d()
  - perspective
  - perspective()
  - perspective-origin
  - rotate
  - rotate3d()
  - rotatex()
  - rotatey()
  - rotatez()
  - scale
  - scale3d()
  - scalez()
  - transform-style
  - translate
  - translate3d()
  - translatez()
- [css-transitions-1] defines the following terms:
  - transition
  - transition-delay
  - transition-duration
  - transition-property
  - transition-timing-function
- [css-ui-4] defines the following terms:
  - appearance
  - caret
  - caret-color
  - caret-shape
  - cursor
  - nav-down
  - nav-left
  - nav-right
  - nav-up
  - outline
  - outline-color
  - outline-offset
  - outline-style
  - outline-width
  - resize
  - user-select
- [css-values-3] defines the following terms:
  - <angle>
  - <length>
  - <number-percentage>
  - <number>
  - <percentage>
  - <resolution>
  - <url>
- [css-values-4] defines the following terms:
  - <angle-percentage>
  - <custom-ident>
  - <dimension>
  - <frequency>
  - <length-percentage>
  - <time-percentage>
  - <time>
  - calc()
  - canonical unit
  - compatible units
  - em
  - ident
  - in
  - math function
  - max()
  - min()
  - percentage
  - px
  - relative length
  - url()
- [css-variables-1] defines the following terms:
  - <custom-property-name>
  - custom property
  - var()
- [css-will-change-1] defines the following terms:
  - will-change
- [css-writing-modes-3] defines the following terms:
  - direction
  - unicode-bidi
- [css-writing-modes-4] defines the following terms:
  - glyph-orientation-vertical
  - text-combine-upright
  - text-orientation
  - writing-mode
- [CSS2] defines the following terms:
  - azimuth
  - border-spacing
  - clear
  - elevation
  - float
  - height
  - line-height
  - page-break-after
  - page-break-before
  - page-break-inside
  - pitch
  - pitch-range
  - play-during
  - richness
  - speak-header
  - speak-numeral
  - speak-punctuation
  - speech-rate
  - stress
  - visibility
  - volume
  - width
- [css3-images] defines the following terms:
  - <image>
  - image-rendering
- [css3-speech] defines the following terms:
  - cue
  - cue-after
  - cue-before
  - pause
  - pause-after
  - pause-before
  - rest
  - rest-after
  - rest-before
  - speak
  - speak-as
  - voice-balance
  - voice-duration
  - voice-family
  - voice-pitch
  - voice-range
  - voice-rate
  - voice-stress
  - voice-volume
- [cssom] defines the following terms:
  - CSS
  - CSSStyleDeclaration
  - CSSStyleRule
  - ElementCSSInlineStyle
  - css declaration block
  - declarations
  - getComputedStyle(elt)
  - origin-clean flag
  - resolved value
- [cssom-view-1] defines the following terms:
  - scroll-behavior
- [DOM] defines the following terms:
  - Element
- [fill-stroke-3] defines the following terms:
  - fill-break
  - fill-color
  - fill-image
  - fill-origin
  - fill-position
  - fill-repeat
  - fill-size
  - stroke-align
  - stroke-break
  - stroke-color
  - stroke-dash-corner
  - stroke-dash-justify
  - stroke-image
  - stroke-origin
  - stroke-position
  - stroke-repeat
  - stroke-size
- [filter-effects-2] defines the following terms:
  - backdrop-filter
- [geometry-1] defines the following terms:
  - DOMMatrix
  - DOMMatrixReadOnly
  - is2D
  - stringification behavior
- [HTML] defines the following terms:
  - HTMLElement
  - style
- [infra] defines the following terms:
  - append
  - ascii lowercase
  - code point
  - contain
  - empty
  - entry
  - exist
  - for each (for map)
  - is empty
  - item
  - key
  - list
  - map
  - ordered map
  - prepend
  - remove (for map)
  - set
  - size (for map)
  - string
  - tuple
  - value
- [motion-1] defines the following terms:
  - offset
  - offset-anchor
  - offset-distance
  - offset-path
  - offset-position
  - offset-rotate
- [SVG11] defines the following terms:
  - color-rendering
- [SVG2] defines the following terms:
  - color-interpolation
  - cx
  - cy
  - d
  - fill
  - fill-opacity
  - fill-rule
  - marker
  - marker-end
  - marker-mid
  - marker-start
  - paint-order
  - pointer-events
  - r
  - rx
  - ry
  - shape-rendering
  - shape-subtract
  - stop-color
  - stop-opacity
  - stroke
  - stroke-dasharray
  - stroke-dashoffset
  - stroke-linecap
  - stroke-linejoin
  - stroke-miterlimit
  - stroke-opacity
  - stroke-width
  - text-anchor
  - text-decoration-fill
  - text-decoration-stroke
  - text-rendering
  - vector-effect
  - x
  - y
- [WebIDL] defines the following terms:
  - DOMString
  - Exposed
  - RangeError
  - SameObject
  - SyntaxError
  - TypeError
  - USVString
  - boolean
  - determine the value of an indexed property
  - double
  - indexed property getter
  - long
  - set the value of a new indexed property
  - set the value of an existing indexed property
  - supported property indices
  - throw
  - unsigned long
  - value pairs to iterate over

## References

### Normative References

[COMPOSITING-2]
  Compositing and Blending Level 2 URL: https://drafts.fxtf.org/compositing-2/
[CSS-ALIGN-3]
  Elika Etemad; Tab Atkins Jr.. CSS Box Alignment Module Level 3. 6 December 2018. WD. URL: https://www.w3.org/TR/css-align-3/
[CSS-ANIMATIONS-1]
  Dean Jackson; et al. CSS Animations Level 1. 11 October 2018. WD. URL: https://www.w3.org/TR/css-animations-1/
[CSS-ANIMATIONS-2]
  CSS Animations Module Level 2 URL: https://drafts.csswg.org/css-animations-2/
[CSS-BACKGROUNDS-3]
  Bert Bos; Elika Etemad; Brad Kemper. CSS Backgrounds and Borders Module Level 3. 17 October 2017. CR. URL: https://www.w3.org/TR/css-backgrounds-3/
[CSS-BOX-3]
  Elika Etemad. CSS Box Model Module Level 3. 18 December 2018. WD. URL: https://www.w3.org/TR/css-box-3/
[CSS-BREAK-3]
  Rossen Atanassov; Elika Etemad. CSS Fragmentation Module Level 3. 4 December 2018. CR. URL: https://www.w3.org/TR/css-break-3/
[CSS-BREAK-4]
  Rossen Atanassov; Elika Etemad. CSS Fragmentation Module Level 4. 18 December 2018. WD. URL: https://www.w3.org/TR/css-break-4/
[CSS-CASCADE-4]
  Elika Etemad; Tab Atkins Jr.. CSS Cascading and Inheritance Level 4. 28 August 2018. CR. URL: https://www.w3.org/TR/css-cascade-4/
[CSS-COLOR-3]
  Tantek Çelik; Chris Lilley; David Baron. CSS Color Module Level 3. 19 June 2018. REC. URL: https://www.w3.org/TR/css-color-3/
[CSS-COLOR-4]
  Tab Atkins Jr.; Chris Lilley. CSS Color Module Level 4. 5 March 2019. WD. URL: https://www.w3.org/TR/css-color-4/
[CSS-COLOR-ADJUST-1]
  Elika Etemad; Rossen Atanassov; Tab Atkins Jr.. CSS Color Adjustment Module Level 1. 23 May 2019. WD. URL: https://www.w3.org/TR/css-color-adjust-1/
[CSS-CONTAIN-1]
  Tab Atkins Jr.; Florian Rivoal. CSS Containment Module Level 1. 30 April 2019. CR. URL: https://www.w3.org/TR/css-contain-1/
[CSS-CONTENT-3]
  Elika Etemad; Dave Cramer. CSS Generated Content Module Level 3. 2 June 2016. WD. URL: https://www.w3.org/TR/css-content-3/
[CSS-DISPLAY-3]
  Tab Atkins Jr.; Elika Etemad. CSS Display Module Level 3. 28 August 2018. CR. URL: https://www.w3.org/TR/css-display-3/
[CSS-FLEXBOX-1]
  Tab Atkins Jr.; et al. CSS Flexible Box Layout Module Level 1. 19 November 2018. CR. URL: https://www.w3.org/TR/css-flexbox-1/
[CSS-FONTS-3]
  John Daggett; Myles Maxfield; Chris Lilley. CSS Fonts Module Level 3. 20 September 2018. REC. URL: https://www.w3.org/TR/css-fonts-3/
[CSS-FONTS-4]
  John Daggett; Myles Maxfield; Chris Lilley. CSS Fonts Module Level 4. 20 September 2018. WD. URL: https://www.w3.org/TR/css-fonts-4/
[CSS-GCPM-4]
  CSS Generated Content for Paged Media Module Level 4 URL: https://drafts.csswg.org/css-gcpm-4/
[CSS-GRID-1]
  Tab Atkins Jr.; Elika Etemad; Rossen Atanassov. CSS Grid Layout Module Level 1. 14 December 2017. CR. URL: https://www.w3.org/TR/css-grid-1/
[CSS-IMAGES-4]
  Tab Atkins Jr.; Elika Etemad; Lea Verou. CSS Image Values and Replaced Content Module Level 4. 13 April 2017. WD. URL: https://www.w3.org/TR/css-images-4/
[CSS-INLINE-3]
  Dave Cramer; Elika Etemad; Steve Zilles. CSS Inline Layout Module Level 3. 8 August 2018. WD. URL: https://www.w3.org/TR/css-inline-3/
[CSS-LINE-GRID-1]
  Elika Etemad; Koji Ishii; Alan Stearns. CSS Line Grid Module Level 1. 16 September 2014. WD. URL: https://www.w3.org/TR/css-line-grid-1/
[CSS-LISTS-3]
  Elika Etemad; Tab Atkins Jr.. CSS Lists Module Level 3. 25 April 2019. WD. URL: https://www.w3.org/TR/css-lists-3/
[CSS-LOGICAL-1]
  Rossen Atanassov; Elika Etemad. CSS Logical Properties and Values Level 1. 27 August 2018. WD. URL: https://www.w3.org/TR/css-logical-1/
[CSS-MASKING-1]
  Dirk Schulze; Brian Birtles; Tab Atkins Jr.. CSS Masking Module Level 1. 26 August 2014. CR. URL: https://www.w3.org/TR/css-masking-1/
[CSS-MULTICOL-2]
  CSS Multi-column Layout Module Level 2 URL: https://drafts.csswg.org/css-multicol-2/
[CSS-OVERFLOW-3]
  David Baron; Elika Etemad; Florian Rivoal. CSS Overflow Module Level 3. 31 July 2018. WD. URL: https://www.w3.org/TR/css-overflow-3/
[CSS-OVERFLOW-4]
  David Baron; Florian Rivoal. CSS Overflow Module Level 4. 13 June 2017. WD. URL: https://www.w3.org/TR/css-overflow-4/
[CSS-PAGE-3]
  Elika Etemad; Simon Sapin. CSS Paged Media Module Level 3. 18 October 2018. WD. URL: https://www.w3.org/TR/css-page-3/
[CSS-PAGE-FLOATS-3]
  Johannes Wilm. CSS Page Floats. 15 September 2015. WD. URL: https://www.w3.org/TR/css-page-floats-3/
[CSS-POSITION-3]
  Rossen Atanassov; Arron Eicholz. CSS Positioned Layout Module Level 3. 17 May 2016. WD. URL: https://www.w3.org/TR/css-position-3/
[CSS-PRESLEV-1]
  CSS Presentation Levels Module Level 1 URL: https://www.w3.org/TR/css3-preslev/
[CSS-REGIONS-1]
  Rossen Atanassov; Alan Stearns. CSS Regions Module Level 1. 9 October 2014. WD. URL: https://www.w3.org/TR/css-regions-1/
[CSS-RHYTHM-1]
  Koji Ishii; Elika Etemad. CSS Rhythmic Sizing. 2 March 2017. WD. URL: https://www.w3.org/TR/css-rhythm-1/
[CSS-ROUND-DISPLAY-1]
  Jihye Hong. CSS Round Display Level 1. 22 December 2016. WD. URL: https://www.w3.org/TR/css-round-display-1/
[CSS-RUBY-1]
  Elika Etemad; Koji Ishii. CSS Ruby Layout Module Level 1. 5 August 2014. WD. URL: https://www.w3.org/TR/css-ruby-1/
[CSS-SCROLL-ANCHORING-1]
  CSS Scroll Anchoring Module Level 1 URL: https://drafts.csswg.org/css-scroll-anchoring/
[CSS-SCROLL-SNAP-1]
  Matt Rakow; et al. CSS Scroll Snap Module Level 1. 19 March 2019. CR. URL: https://www.w3.org/TR/css-scroll-snap-1/
[CSS-SHAPES-1]
  Vincent Hardy; Rossen Atanassov; Alan Stearns. CSS Shapes Module Level 1. 20 March 2014. CR. URL: https://www.w3.org/TR/css-shapes-1/
[CSS-SHAPES-2]
  CSS Shapes Module Level 2 URL: https://drafts.csswg.org/css-shapes-2/
[CSS-SIZE-ADJUST-1]
  CSS Mobile Text Size Adjustment Module Level 1 URL: https://drafts.csswg.org/css-size-adjust-1/
[CSS-SIZING-3]
  Tab Atkins Jr.; Elika Etemad. CSS Intrinsic & Extrinsic Sizing Module Level 3. 22 May 2019. WD. URL: https://www.w3.org/TR/css-sizing-3/
[CSS-SYNTAX-3]
  Tab Atkins Jr.; Simon Sapin. CSS Syntax Module Level 3. 20 February 2014. CR. URL: https://www.w3.org/TR/css-syntax-3/
[CSS-TABLES-3]
  Greg Whitworth. CSS Table Module Level 3. 7 March 2017. WD. URL: https://www.w3.org/TR/css-tables-3/
[CSS-TEXT-3]
  Elika Etemad; Koji Ishii; Florian Rivoal. CSS Text Module Level 3. 12 December 2018. WD. URL: https://www.w3.org/TR/css-text-3/
[CSS-TEXT-4]
  Elika Etemad; Koji Ishii; Alan Stearns. CSS Text Module Level 4. 20 September 2018. WD. URL: https://www.w3.org/TR/css-text-4/
[CSS-TEXT-DECOR-3]
  Elika Etemad; Koji Ishii. CSS Text Decoration Module Level 3. 3 July 2018. CR. URL: https://www.w3.org/TR/css-text-decor-3/
[CSS-TEXT-DECOR-4]
  Elika Etemad; Koji Ishii. CSS Text Decoration Module Level 4. 13 March 2018. WD. URL: https://www.w3.org/TR/css-text-decor-4/
[CSS-TRANSFORMS-1]
  Simon Fraser; et al. CSS Transforms Module Level 1. 14 February 2019. CR. URL: https://www.w3.org/TR/css-transforms-1/
[CSS-TRANSFORMS-2]
  CSS Transforms Module Level 2 URL: https://drafts.csswg.org/css-transforms-2/
[CSS-TRANSITIONS-1]
  David Baron; et al. CSS Transitions. 11 October 2018. WD. URL: https://www.w3.org/TR/css-transitions-1/
[CSS-UI-4]
  Florian Rivoal. CSS Basic User Interface Module Level 4. 22 December 2017. WD. URL: https://www.w3.org/TR/css-ui-4/
[CSS-VALUES-3]
  Tab Atkins Jr.; Elika Etemad. CSS Values and Units Module Level 3. 31 January 2019. CR. URL: https://www.w3.org/TR/css-values-3/
[CSS-VALUES-4]
  Tab Atkins Jr.; Elika Etemad. CSS Values and Units Module Level 4. 31 January 2019. WD. URL: https://www.w3.org/TR/css-values-4/
[CSS-VARIABLES-1]
  Tab Atkins Jr.. CSS Custom Properties for Cascading Variables Module Level 1. 3 December 2015. CR. URL: https://www.w3.org/TR/css-variables-1/
[CSS-WILL-CHANGE-1]
  Tab Atkins Jr.. CSS Will Change Module Level 1. 3 December 2015. CR. URL: https://www.w3.org/TR/css-will-change-1/
[CSS-WRITING-MODES-3]
  Elika Etemad; Koji Ishii. CSS Writing Modes Level 3. 24 May 2018. CR. URL: https://www.w3.org/TR/css-writing-modes-3/
[CSS-WRITING-MODES-4]
  Elika Etemad; Koji Ishii. CSS Writing Modes Level 4. 24 May 2018. CR. URL: https://www.w3.org/TR/css-writing-modes-4/
[CSS2]
  Bert Bos; et al. Cascading Style Sheets Level 2 Revision 1 (CSS 2.1) Specification. 7 June 2011. REC. URL: https://www.w3.org/TR/CSS2/
[CSS3-IMAGES]
  Elika Etemad; Tab Atkins Jr.. CSS Image Values and Replaced Content Module Level 3. 17 April 2012. CR. URL: https://www.w3.org/TR/css3-images/
[CSS3-SPEECH]
  Daniel Weck. CSS Speech Module. 5 June 2018. NOTE. URL: https://www.w3.org/TR/css3-speech/
[CSSOM]
  Simon Pieters; Glenn Adams. CSS Object Model (CSSOM). 17 March 2016. WD. URL: https://www.w3.org/TR/cssom-1/
[CSSOM-VIEW-1]
  Simon Pieters. CSSOM View Module. 17 March 2016. WD. URL: https://www.w3.org/TR/cssom-view-1/
[DOM]
  Anne van Kesteren. DOM Standard. Living Standard. URL: https://dom.spec.whatwg.org/
[FILL-STROKE-3]
  Elika Etemad; Tab Atkins Jr.. CSS Fill and Stroke Module Level 3. 13 April 2017. WD. URL: https://www.w3.org/TR/fill-stroke-3/
[FILTER-EFFECTS-2]
  Filter Effects Level 2 URL: https://drafts.fxtf.org/filter-effects-2/
[GEOMETRY-1]
  Simon Pieters; Chris Harrelson. Geometry Interfaces Module Level 1. 4 December 2018. CR. URL: https://www.w3.org/TR/geometry-1/
[HTML]
  Anne van Kesteren; et al. HTML Standard. Living Standard. URL: https://html.spec.whatwg.org/multipage/
[INFRA]
  Anne van Kesteren; Domenic Denicola. Infra Standard. Living Standard. URL: https://infra.spec.whatwg.org/
[MOTION-1]
  Dirk Schulze; et al. Motion Path Module Level 1. 18 December 2018. WD. URL: https://www.w3.org/TR/motion-1/
[RFC2119]
  S. Bradner. Key words for use in RFCs to Indicate Requirement Levels. March 1997. Best Current Practice. URL: https://tools.ietf.org/html/rfc2119
[SVG11]
  Erik Dahlström; et al. Scalable Vector Graphics (SVG) 1.1 (Second Edition). 16 August 2011. REC. URL: https://www.w3.org/TR/SVG11/
[SVG2]
  Amelia Bellamy-Royds; et al. Scalable Vector Graphics (SVG) 2. 4 October 2018. CR. URL: https://www.w3.org/TR/SVG2/
[WebIDL]
  Boris Zbarsky. Web IDL. 15 December 2016. ED. URL: https://heycam.github.io/webidl/

## IDL Index

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSStyleValue {
        stringifier;
        [Exposed=Window] static CSSStyleValue parse(USVString property, USVString cssText);
        [Exposed=Window] static sequence<CSSStyleValue> parseAll(USVString property, USVString cssText);
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface StylePropertyMapReadOnly {
        iterable<USVString, sequence<CSSStyleValue>>;
        any get(USVString property);
        /* 'any' means (undefined or CSSStyleValue) here,
           see https://github.com/heycam/webidl/issues/60 */
        sequence<CSSStyleValue> getAll(USVString property);
        boolean has(USVString property);
        readonly attribute unsigned long size;
    };

    [Exposed=Window]
    interface StylePropertyMap : StylePropertyMapReadOnly {
        void set(USVString property, (CSSStyleValue or USVString)... values);
        void append(USVString property, (CSSStyleValue or USVString)... values);
        void delete(USVString property);
        void clear();
    };

    partial interface Element {
        [SameObject] StylePropertyMapReadOnly computedStyleMap();
    };

    partial interface CSSStyleRule {
        [SameObject] readonly attribute StylePropertyMap styleMap;
    };

    partial interface mixin ElementCSSInlineStyle {
        [SameObject] readonly attribute StylePropertyMap attributeStyleMap;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(sequence<CSSUnparsedSegment> members)]
    interface CSSUnparsedValue : CSSStyleValue {
        iterable<CSSUnparsedSegment>;
        readonly attribute unsigned long length;
        getter CSSUnparsedSegment (unsigned long index);
        setter CSSUnparsedSegment (unsigned long index, CSSUnparsedSegment val);
    };

    typedef (USVString or CSSVariableReferenceValue) CSSUnparsedSegment;

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(USVString variable, optional CSSUnparsedValue? fallback = null)]
    interface CSSVariableReferenceValue {
        attribute USVString variable;
        readonly attribute CSSUnparsedValue? fallback;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(USVString value)]
    interface CSSKeywordValue : CSSStyleValue {
        attribute USVString value;
    };

    typedef (DOMString or CSSKeywordValue) CSSKeywordish;

    typedef (double or CSSNumericValue) CSSNumberish;

    enum CSSNumericBaseType {
        "length",
        "angle",
        "time",
        "frequency",
        "resolution",
        "flex",
        "percent",
    };

    dictionary CSSNumericType {
        long length;
        long angle;
        long time;
        long frequency;
        long resolution;
        long flex;
        long percent;
        CSSNumericBaseType percentHint;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSNumericValue : CSSStyleValue {
        CSSNumericValue add(CSSNumberish... values);
        CSSNumericValue sub(CSSNumberish... values);
        CSSNumericValue mul(CSSNumberish... values);
        CSSNumericValue div(CSSNumberish... values);
        CSSNumericValue min(CSSNumberish... values);
        CSSNumericValue max(CSSNumberish... values);

        boolean equals(CSSNumberish... value);

        CSSUnitValue to(USVString unit);
        CSSMathSum toSum(USVString... units);
        CSSNumericType type();

        [Exposed=Window] static CSSNumericValue parse(USVString cssText);
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(double value, USVString unit)]
    interface CSSUnitValue : CSSNumericValue {
        attribute double value;
        readonly attribute USVString unit;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSMathValue : CSSNumericValue {
        readonly attribute CSSMathOperator operator;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathSum : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathProduct : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish arg)]
    interface CSSMathNegate : CSSMathValue {
        readonly attribute CSSNumericValue value;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish arg)]
    interface CSSMathInvert : CSSMathValue {
        readonly attribute CSSNumericValue value;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathMin : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish... args)]
    interface CSSMathMax : CSSMathValue {
        readonly attribute CSSNumericArray values;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish min, CSSNumberish val, CSSNumberish max)]
    interface CSSMathClamp : CSSMathValue {
        readonly attribute CSSNumericValue min;
        readonly attribute CSSNumericValue val;
        readonly attribute CSSNumericValue max;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSNumericArray {
        iterable<CSSNumericValue>;
        readonly attribute unsigned long length;
        getter CSSNumericValue (unsigned long index);
    };

    enum CSSMathOperator {
        "sum",
        "product",
        "negate",
        "invert",
        "min",
        "max",
        "clamp",
    };

    partial namespace CSS {
        CSSUnitValue number(double value);
        CSSUnitValue percent(double value);

        // <length>
        CSSUnitValue em(double value);
        CSSUnitValue ex(double value);
        CSSUnitValue ch(double value);
        CSSUnitValue ic(double value);
        CSSUnitValue rem(double value);
        CSSUnitValue lh(double value);
        CSSUnitValue rlh(double value);
        CSSUnitValue vw(double value);
        CSSUnitValue vh(double value);
        CSSUnitValue vi(double value);
        CSSUnitValue vb(double value);
        CSSUnitValue vmin(double value);
        CSSUnitValue vmax(double value);
        CSSUnitValue cm(double value);
        CSSUnitValue mm(double value);
        CSSUnitValue Q(double value);
        CSSUnitValue in(double value);
        CSSUnitValue pt(double value);
        CSSUnitValue pc(double value);
        CSSUnitValue px(double value);

        // <angle>
        CSSUnitValue deg(double value);
        CSSUnitValue grad(double value);
        CSSUnitValue rad(double value);
        CSSUnitValue turn(double value);

        // <time>
        CSSUnitValue s(double value);
        CSSUnitValue ms(double value);

        // <frequency>
        CSSUnitValue Hz(double value);
        CSSUnitValue kHz(double value);

        // <resolution>
        CSSUnitValue dpi(double value);
        CSSUnitValue dpcm(double value);
        CSSUnitValue dppx(double value);

        // <flex>
        CSSUnitValue fr(double value);
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(sequence<CSSTransformComponent> transforms)]
    interface CSSTransformValue : CSSStyleValue {
        iterable<CSSTransformComponent>;
        readonly attribute unsigned long length;
        getter CSSTransformComponent (unsigned long index);
        setter CSSTransformComponent (unsigned long index, CSSTransformComponent val);

        readonly attribute boolean is2D;
        DOMMatrix toMatrix();
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSTransformComponent {
        stringifier;
        attribute boolean is2D;
        DOMMatrix toMatrix();
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue x, CSSNumericValue y, optional CSSNumericValue z)]
    interface CSSTranslate : CSSTransformComponent {
        attribute CSSNumericValue x;
        attribute CSSNumericValue y;
        attribute CSSNumericValue z;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue angle),
     Constructor(CSSNumberish x, CSSNumberish y, CSSNumberish z, CSSNumericValue angle)]
    interface CSSRotate : CSSTransformComponent {
        attribute CSSNumberish x;
        attribute CSSNumberish y;
        attribute CSSNumberish z;
        attribute CSSNumericValue angle;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumberish x, CSSNumberish y, optional CSSNumberish z)]
    interface CSSScale : CSSTransformComponent {
        attribute CSSNumberish x;
        attribute CSSNumberish y;
        attribute CSSNumberish z;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue ax, CSSNumericValue ay)]
    interface CSSSkew : CSSTransformComponent {
        attribute CSSNumericValue ax;
        attribute CSSNumericValue ay;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue ax)]
    interface CSSSkewX : CSSTransformComponent {
        attribute CSSNumericValue ax;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue ay)]
    interface CSSSkewY : CSSTransformComponent {
        attribute CSSNumericValue ay;
    };

    /* Note that skew(x,y) is *not* the same as skewX(x) skewY(y),
       thus the separate interfaces for all three. */

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(CSSNumericValue length)]
    interface CSSPerspective : CSSTransformComponent {
        attribute CSSNumericValue length;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet),
     Constructor(DOMMatrixReadOnly matrix, optional CSSMatrixComponentOptions options = {})]
    interface CSSMatrixComponent : CSSTransformComponent {
        attribute DOMMatrix matrix;
    };

    dictionary CSSMatrixComponentOptions {
        boolean is2D;
    };

    [Exposed=(Window, Worker, PaintWorklet, LayoutWorklet)]
    interface CSSImageValue : CSSStyleValue {
    };

## Issues Index

Define the global. ↵
How to divide a list-valued property into iterations is intentionally undefined and hand-wavey at the moment. Generally, you just split it on top-level commas (corresponding to a top-level `<foo>#` term in the grammar), but some legacy properties (such as counter-reset) don’t separate their iterations with commas.

It’s expected to be rigorously defined in the future, but at the moment is explicitly a "you know what we mean" thing.

↵
Define precisely which properties are list-valued and which aren’t, probably in an appendix. <https://github.com/w3c/css-houdini-drafts/issues/644> ↵
Define the global. ↵
Define the global. ↵
#css-internal-representation Referenced in:

- 1. Introduction (2) (3) (4) (5) (6) (7)
- 2.1. Direct CSSStyleValue Objects (2) (3)
- 3. The StylePropertyMap
- 5. CSSStyleValue Reification (2) (3)
- 5.2. Unrepresentable Values

#cssstylevalue Referenced in:

- 2. CSSStyleValue objects (2) (3) (4) (5)
- 2.1. Direct CSSStyleValue Objects (2) (3) (4) (5) (6)
- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7) (8) (9) (10)
- 4. CSSStyleValue subclasses
- 4.1. CSSUnparsedValue objects
- 4.2. CSSKeywordValue objects
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 4.4. CSSTransformValue objects
- 4.5. CSSImageValue objects
- 5. CSSStyleValue Reification
- 5.1. Property-specific Rules (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23) (24) (25) (26) (27) (28) (29) (30) (31) (32)
- 5.2. Unrepresentable Values (2)
- 6. CSSStyleValue Serialization (2)
- 6.7. Serialization from CSSOM Values

#CSSStyleValue-stringification-behavior Referenced in:

- 2. CSSStyleValue objects

#dom-cssstylevalue-parse Referenced in:

- 2. CSSStyleValue objects

#dom-cssstylevalue-parseall Referenced in:

- 2. CSSStyleValue objects

#parse-a-cssstylevalue Referenced in:

- 2. CSSStyleValue objects (2)
- 3. The StylePropertyMap

#subdivide-into-iterations Referenced in:

- 2. CSSStyleValue objects
- 3. The StylePropertyMap (2) (3)

#dom-cssstylevalue-associatedproperty-slot Referenced in:

- 2.1. Direct CSSStyleValue Objects
- 3. The StylePropertyMap (2) (3) (4)
- 5.2. Unrepresentable Values

#stylepropertymapreadonly Referenced in:

- 3. The StylePropertyMap (2) (3)
- 3.1. Computed StylePropertyMapReadOnly objects (2) (3) (4)

#stylepropertymap Referenced in:

- 2.1. Direct CSSStyleValue Objects
- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12)
- 3.2. Declared & Inline StylePropertyMap objects (2) (3)
- 5. CSSStyleValue Reification

#dom-stylepropertymapreadonly-declarations-slot Referenced in:

- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7) (8) (9) (10)
- 3.1. Computed StylePropertyMapReadOnly objects (2)
- 3.2. Declared & Inline StylePropertyMap objects

#list-valued-properties Referenced in:

- 2. CSSStyleValue objects
- 3. The StylePropertyMap (2) (3)
- 5. CSSStyleValue Reification

#single-valued-properties Referenced in:

- 2. CSSStyleValue objects
- 3. The StylePropertyMap (2) (3)

#dom-stylepropertymapreadonly-get Referenced in:

- 3. The StylePropertyMap

#dom-stylepropertymapreadonly-getall Referenced in:

- 3. The StylePropertyMap
- 5. CSSStyleValue Reification

#dom-stylepropertymapreadonly-has Referenced in:

- 3. The StylePropertyMap

#dom-stylepropertymap-set Referenced in:

- 2.1. Direct CSSStyleValue Objects
- 3. The StylePropertyMap

#dom-stylepropertymap-append Referenced in:

- 2.1. Direct CSSStyleValue Objects
- 3. The StylePropertyMap

#dom-stylepropertymap-delete Referenced in:

- 3. The StylePropertyMap

#dom-stylepropertymap-clear Referenced in:

- 3. The StylePropertyMap

#create-an-internal-representation Referenced in:

- 3. The StylePropertyMap (2)

#cssstylevalue-match-a-grammar Referenced in:

- 3. The StylePropertyMap

#custom-property-name-string Referenced in:

- 2. CSSStyleValue objects
- 3. The StylePropertyMap (2) (3) (4) (5) (6) (7)
- 4.1. CSSUnparsedValue objects (2)

#valid-css-property Referenced in:

- 2. CSSStyleValue objects
- 3. The StylePropertyMap (2) (3) (4) (5) (6)

#dom-element-computedstylemapcache-slot Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects (2)

#dom-element-computedstylemap Referenced in:

- 3.1. Computed StylePropertyMapReadOnly objects (2) (3)
- 4.5. CSSImageValue objects

#declared-stylepropertymap Referenced in:

- 3.2. Declared & Inline StylePropertyMap objects
- 4.3. Numeric Values:

#dom-cssstylerule-stylemap Referenced in:

- 3.2. Declared & Inline StylePropertyMap objects

#dom-elementcssinlinestyle-attributestylemap Referenced in:

- 3.2. Declared & Inline StylePropertyMap objects

#cssunparsedvalue Referenced in:

- 3. The StylePropertyMap (2) (3)
- 4.1. CSSUnparsedValue objects (2) (3) (4) (5) (6) (7) (8)
- 4.3. Numeric Values:
- 5.3. Raw CSS tokens: properties with var() references (2) (3) (4) (5)
- 6.1. CSSUnparsedValue Serialization (2)

#typedefdef-cssunparsedsegment Referenced in:

- 4.1. CSSUnparsedValue objects (2) (3) (4) (5)

#cssvariablereferencevalue Referenced in:

- 3. The StylePropertyMap (2)
- 4.1. CSSUnparsedValue objects (2) (3) (4) (5)
- 5.3. Raw CSS tokens: properties with var() references (2) (3) (4)
- 5.4. var() References (2)
- 6.1. CSSUnparsedValue Serialization (2)

#dom-cssvariablereferencevalue-fallback Referenced in:

- 4.1. CSSUnparsedValue objects
- 5.3. Raw CSS tokens: properties with var() references (2) (3)
- 5.4. var() References
- 6.1. CSSUnparsedValue Serialization (2)

#dom-cssunparsedvalue-tokens-slot Referenced in:

- 4.1. CSSUnparsedValue objects (2) (3) (4) (5)
- 5.3. Raw CSS tokens: properties with var() references
- 6.1. CSSUnparsedValue Serialization

#dom-cssunparsedvalue-length Referenced in:

- 4.1. CSSUnparsedValue objects

#dom-cssvariablereferencevalue-variable Referenced in:

- 4.1. CSSUnparsedValue objects (2) (3) (4) (5)
- 5.3. Raw CSS tokens: properties with var() references (2) (3)
- 5.4. var() References
- 6.1. CSSUnparsedValue Serialization

#csskeywordvalue Referenced in:

- 3. The StylePropertyMap
- 4.2. CSSKeywordValue objects (2) (3) (4) (5) (6) (7) (8)
- 4.3. Numeric Values:
- 5.5. Identifier Values (2)
- 6.2. CSSKeywordValue Serialization (2)

#dom-csskeywordvalue-value Referenced in:

- 3. The StylePropertyMap
- 4.2. CSSKeywordValue objects (2) (3) (4)
- 5.5. Identifier Values
- 6.2. CSSKeywordValue Serialization

#typedefdef-cssnumberish Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5) (6) (7) (8) (9)
- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12)

#rectify-a-numberish-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)
- 4.4. CSSTransformValue objects (2) (3) (4)

#enumdef-cssnumericbasetype Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#dictdef-cssnumerictype Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

#dom-cssnumerictype-percenthint Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#cssnumericvalue Referenced in:

- 3. The StylePropertyMap
- 4.3. Numeric Values: (2) (3) (4) (5) (6) (7)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23) (24) (25) (26) (27) (28)
- 4.3.2. Numeric Value Typing
- 4.3.3. Value + Unit: CSSUnitValue objects
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10)
- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19)
- 5.6. <number>, <percentage>, and <dimension> values

#dom-cssnumericvalue-add Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

#dom-cssnumericvalue-sub Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#cssmath-negate-a-cssnumericvalue Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#dom-cssnumericvalue-mul Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

#dom-cssnumericvalue-div Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#cssmath-invert-a-cssnumericvalue Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#dom-cssnumericvalue-min Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#dom-cssnumericvalue-max Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#dom-cssnumericvalue-equals Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#equal-numeric-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssnumericvalue-to Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

#create-a-cssunitvalue-from-a-sum-value-item Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

#dom-cssnumericvalue-tosum Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#dom-cssnumericvalue-type Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#cssnumericvalue-sum-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5)

#sum-value-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10) (11)

#sum-value-unit-map Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10)

#create-a-sum-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8)

#create-a-type-from-a-unit-map Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#product-of-two-unit-maps Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass

#dom-cssnumericvalue-parse Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

#cssnumericvalue-type Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7)
- 4.3.2. Numeric Value Typing (2) (3) (4) (5) (6) (7) (8) (9) (10) (11)
- 4.3.3. Value + Unit: CSSUnitValue objects
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13)

#cssnumericvalue-base-type Referenced in:

- 4.3.2. Numeric Value Typing (2) (3) (4) (5)

#cssnumericvalue-percent-hint Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)
- 4.3.2. Numeric Value Typing (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20)

#cssnumericvalue-create-a-type Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 4.3.3. Value + Unit: CSSUnitValue objects (2)

#cssnumericvalue-add-two-types Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 4.3.2. Numeric Value Typing (2)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5)

#apply-the-percent-hint Referenced in:

- 4.3.2. Numeric Value Typing (2) (3)

#cssnumericvalue-multiply-two-types Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)

#cssnumericvalue-match Referenced in:

- 3. The StylePropertyMap
- 4.3.2. Numeric Value Typing
- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10)

#cssunitvalue Referenced in:

- 3. The StylePropertyMap
- 4.3. Numeric Values: (2)
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22)
- 4.3.3. Value + Unit: CSSUnitValue objects (2) (3) (4) (5) (6) (7) (8)
- 4.3.4. Complex Numeric Values: CSSMathValue objects
- 4.3.5. Numeric Factory Functions (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23) (24) (25) (26) (27) (28) (29) (30) (31) (32) (33) (34) (35) (36)
- 5.6. <number>, <percentage>, and <dimension> values (2)
- 6.3. CSSUnitValue Serialization (2)
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssunitvalue-value Referenced in:

- 4.3. Numeric Values:
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20)
- 4.3.3. Value + Unit: CSSUnitValue objects (2) (3) (4)
- 4.3.5. Numeric Factory Functions
- 5.6. <number>, <percentage>, and <dimension> values (2)
- 6.3. CSSUnitValue Serialization
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssunitvalue-unit Referenced in:

- 4.3. Numeric Values:
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23)
- 4.3.3. Value + Unit: CSSUnitValue objects (2) (3) (4) (5)
- 4.3.5. Numeric Factory Functions
- 5.6. <number>, <percentage>, and <dimension> values (2)
- 6.3. CSSUnitValue Serialization

#create-a-cssunitvalue-from-a-pair Referenced in:

- 4.3.3. Value + Unit: CSSUnitValue objects
- 4.4. CSSTransformValue objects (2) (3) (4)

#convert-a-cssunitvalue Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2)

#cssmathvalue Referenced in:

- 4.3. Numeric Values:
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10)
- 6.4. CSSMathValue Serialization (2)

#cssmathsum Referenced in:

- 3. The StylePropertyMap
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization

#dom-cssmathsum-values Referenced in:

- 3. The StylePropertyMap
- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5) (6) (7) (8) (9)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization (2)

#cssmathproduct Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization

#dom-cssmathproduct-values Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 4.3.4. Complex Numeric Values: CSSMathValue objects
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization (2)

#cssmathnegate Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization (2)

#dom-cssmathnegate-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4) (5)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization (2)

#cssmathinvert Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization (2)

#dom-cssmathinvert-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 4.3.4. Complex Numeric Values: CSSMathValue objects
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization (2)

#cssmathmin Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization

#dom-cssmathmin-values Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization

#cssmathmax Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3) (4)
- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)
- 5.6. <number>, <percentage>, and <dimension> values
- 6.4. CSSMathValue Serialization

#dom-cssmathmax-values Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass (2) (3)

#cssmathclamp Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3)

#dom-cssmathclamp-min Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)

#dom-cssmathclamp-val Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)

#dom-cssmathclamp-max Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)

#cssnumericarray Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects (2) (3) (4) (5) (6) (7)

#enumdef-cssmathoperator Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects (2)

#dom-cssmathvalue-operator Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects

#dom-cssnumericarray-length Referenced in:

- 4.3.4. Complex Numeric Values: CSSMathValue objects

#csstransformvalue Referenced in:

- 3. The StylePropertyMap
- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11)
- 5.7. <transform-list> and <transform-function> values (2)
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2)

#dom-csstransformvalue-is2d Referenced in:

- 4.4. CSSTransformValue objects (2) (3)
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2) (3)

#dom-csstransformvalue-tomatrix Referenced in:

- 4.4. CSSTransformValue objects

#dom-csstransformvalue-length Referenced in:

- 4.4. CSSTransformValue objects

#dom-csstransformvalue-values-slot Referenced in:

- 4.4. CSSTransformValue objects (2) (3) (4)

#csstransformcomponent Referenced in:

- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#csstranslate Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-csstranslate-x Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2)

#dom-csstranslate-y Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2)

#dom-csstranslate-z Referenced in:

- 4.4. CSSTransformValue objects (2) (3)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#cssrotate Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssrotate-angle Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2)

#cssscale Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#cssskew Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssskew-ax Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssskew-ay Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2)

#cssskewx Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssskewx-ax Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#cssskewy Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssskewy-ay Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#cssperspective Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssperspective-length Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#cssmatrixcomponent Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssmatrixcomponent-matrix Referenced in:

- 4.4. CSSTransformValue objects
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dictdef-cssmatrixcomponentoptions Referenced in:

- 4.4. CSSTransformValue objects

#dom-cssmatrixcomponentoptions-is2d Referenced in:

- 4.4. CSSTransformValue objects

#dom-csstransformcomponent-is2d Referenced in:

- 4.4. CSSTransformValue objects (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16)
- 5.7. <transform-list> and <transform-function> values (2) (3) (4) (5) (6) (7) (8)

#dom-csstransformcomponent-tomatrix Referenced in:

- 4.4. CSSTransformValue objects (2)

#dom-cssrotate-x Referenced in:

- 4.4. CSSTransformValue objects (2) (3)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssrotate-y Referenced in:

- 4.4. CSSTransformValue objects (2) (3)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssrotate-z Referenced in:

- 4.4. CSSTransformValue objects (2) (3)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#dom-cssscale-x Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2) (3)

#dom-cssscale-y Referenced in:

- 4.4. CSSTransformValue objects (2)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization (2) (3)

#dom-cssscale-z Referenced in:

- 4.4. CSSTransformValue objects (2) (3)
- 5.7. <transform-list> and <transform-function> values
- 6.5. CSSTransformValue and CSSTransformComponent Serialization

#cssimagevalue Referenced in:

- 3. The StylePropertyMap
- 4.5. CSSImageValue objects (2) (3)

#css-reify Referenced in:

- 2. CSSStyleValue objects
- 2.1. Direct CSSStyleValue Objects
- 3. The StylePropertyMap (2) (3)
- 5. CSSStyleValue Reification
- 5.1. Property-specific Rules
- 5.2. Unrepresentable Values
- 5.6. <number>, <percentage>, and <dimension> values (2)

#reify-as-a-cssstylevalue Referenced in:

- 5.2. Unrepresentable Values

#reify-a-list-of-component-values Referenced in:

- 5. CSSStyleValue Reification
- 5.1. Property-specific Rules
- 5.4. var() References

#reify-an-identifier Referenced in:

- 5.1. Property-specific Rules (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22) (23) (24) (25) (26) (27) (28) (29) (30) (31) (32) (33) (34) (35) (36) (37) (38) (39) (40) (41) (42) (43) (44) (45) (46) (47) (48) (49) (50) (51) (52) (53) (54) (55) (56) (57) (58) (59) (60) (61) (62) (63) (64) (65) (66) (67) (68) (69) (70) (71) (72) (73) (74) (75) (76) (77) (78) (79)

#reify-a-numeric-value Referenced in:

- 4.3.1. Common Numeric Operations, and the CSSNumericValue Superclass
- 5.1. Property-specific Rules (2) (3) (4) (5) (6) (7) (8) (9) (10) (11) (12) (13) (14) (15) (16) (17) (18) (19) (20) (21) (22)
- 5.7. <transform-list> and <transform-function> values (2) (3) (4) (5) (6) (7) (8) (9) (10)

#reify-a-math-expression Referenced in:

- 5.6. <number>, <percentage>, and <dimension> values (2)

#reify-a-transform-function Referenced in:

- 5.7. <transform-list> and <transform-function> values