@webref/css 4.2.1 → 4.3.0

package/css-position.json

@@ -181,12 +181,5 @@
     }
   },
   "descriptors": {},
-  "valuespaces": {
-    "<length>": {
-      "prose": "The inset is a fixed distance from the reference edge. Negative values are allowed."
-    },
-    "<percentage>": {
-      "prose": "The inset is a percentage relative to the containing block’s size in the corresponding axis (e.g. width for left or right, height for top and bottom). For sticky positioned boxes, the inset is instead relative to the relevant scrollport’s size. Negative values are allowed."
-    }
-  }
+  "valuespaces": {}
 }

package/css-shapes-2.json

@@ -37,49 +37,44 @@
   },
   "descriptors": {},
   "valuespaces": {
-    "<shape()>": {
-      "value": "shape( <'fill-rule'>? from <coordinate-pair>, <shape-command>#)"
-    },
     "<shape-command>": {
+      "prose": "The sequence of <shape-command>s represent further path data commands. Each command’s starting point is the previous command’s ending point.",
       "value": "<move-command> | <line-command> | <hv-line-command> | <curve-command> | <smooth-command> | <arc-command> | close"
     },
     "<coordinate-pair>": {
-      "value": "<length-percentage>{2}",
-      "prose": "Defines a pair of coordinates, representing a rightward and downward offset, respectively, from a specified reference point. Percentages are resolved against the width or height, respectively, of the reference box."
+      "value": "<length-percentage>{2}"
     },
     "<by-to>": {
-      "value": "by | to",
-      "prose": "Every command can be specified in \"absolute\" or \"relative\" coordinates, determined by their <by-to> component. to indicates that any <coordinate-pair>s in the command are relative to the top-left corner of the reference box, while by indicates that the <coordinate-pair>s are relative to the command’s starting point."
+      "value": "by | to"
     },
     "<move-command>": {
-      "value": "move <by-to> <coordinate-pair>",
-      "prose": "Adds a moveto command to the list of path data commands, with an ending point specified by the <coordinate-pair>. This draws nothing, and merely \"moves the pen\" for the next command."
+      "value": "move <by-to> <coordinate-pair>"
     },
     "<line-command>": {
-      "value": "line <by-to> <coordinate-pair>",
-      "prose": "Adds a lineto command to the list of path data commands, with an ending point specified by the <coordinate-pair>. This draws a straight line from the command’s starting point to its ending point."
+      "value": "line <by-to> <coordinate-pair>"
     },
     "<hv-line-command>": {
-      "value": "[hline | vline] <by-to> <length-percentage>",
-      "prose": "Adds a horizontal (for hline) or vertical (for vline) lineto command to the list of path data commands. This is equivalent to a line command with the <length-percentage> given as the horizontal or vertical component, respectively, of the <coordinate-pair>, and the other component specified appropriately to make the line horizontal or vertical."
+      "value": "[hline | vline] <by-to> <length-percentage>"
     },
     "<curve-command>": {
-      "value": "curve <by-to> <coordinate-pair> via <coordinate-pair>{1,2}",
-      "prose": "Adds a Bézier curve command to the list of path data commands, ending at the point specified by the first <coordinate-pair>. The via component specifies control points for the curve: if a single <coordinate-pair> is provided, the command specifies a quadratic curve; if two <coordinate-pair>s are provided, it specifies a cubic curve."
+      "value": "curve <by-to> <coordinate-pair> via <coordinate-pair>{1,2}"
     },
     "<smooth-command>": {
-      "value": "smooth <by-to> <coordinate-pair> [via <coordinate-pair>]?",
-      "prose": "Adds a smooth Bézier curve command to the list of path data commands, ending at the point specified by the first <coordinate-pair>. The via component specifies control points for the curve: if it’s omitted, the command specifies a smooth quadratic curve; if it’s provided, if specifies a smooth cubic curve."
+      "value": "smooth <by-to> <coordinate-pair> [via <coordinate-pair>]?"
     },
     "<arc-command>": {
-      "value": "arc <by-to> <coordinate-pair> of <length-percentage>{1,2} [ <arc-sweep> || <arc-size> || rotate <angle> ]?",
-      "prose": "Add an elliptical arc command to the list of path data commands, ending at the point specified by the <coordinate-pair>. The of component specifies the size of the ellipse that the arc is taken from. The first <length-percentage> provides the horizontal radius of the ellipse and the second provides the vertical radius. Like for <coordinate-pair>s, <percentage> values are resolved against the width or height of the reference box, as appropriate. If only one <length-percentage> is provided, both radiuses use the provided value. In that case, <percentage> values are resolved against the direction-agnostic size of the reference box (similar to the circle() function). The ellipse described by the specified radiuses defaults to being axis-aligned, but can be rotated by specifying an <angle>. Similar to the rotate() transform function, positive angles specify a clockwise rotation, and negative angles specify a counterclockwise rotation. If omitted, this defaults to 0deg. The ending point, radiuses, and angle, taken together, usually define two possible ellipses that intersect the starting point and ending point, and each ellipse can be traced in either direction, for a total of four possible arcs. The <arc-sweep> and <arc-size> components specify which of these arcs is desired: <arc-sweep> can be cw or ccw, indicating that the arc that is traced around the ellipse clockwise or counter-clockwise from the center, respectively, must be chosen. If omitted, this defaults to ccw. Note: In the SVG arc command, cw corresponds to the value 1 for the sweep flag, and ccw to the value 0. <arc-size> can be large or small, indicating that the larger or smaller, respectively, of the two possible arcs must be chosen. If omitted, this defaults to small. Note: In the SVG arc command, large corresponds to the value 1 for the large flag, and small to the 0. Note: If the starting and ending points are on exactly opposite sides of the ellipse, both possible arcs are the same size, but also there is only one possible ellipse. In this case, the <arc-sweep> distinguishes which of the two possible arcs will be chosen, and <arc-size> has no effect. A depiction of the two possible ellipses, and four possible arcs, that can be chosen between."
+      "value": "arc <by-to> <coordinate-pair> of <length-percentage>{1,2} [ <arc-sweep> || <arc-size> || rotate <angle> ]"
     },
     "<arc-sweep>": {
+      "prose": "<arc-sweep> can be cw or ccw, indicating that the arc that is traced around the ellipse clockwise or counter-clockwise from the center, respectively, must be chosen. If omitted, this defaults to ccw.",
       "value": "cw | ccw"
     },
     "<arc-size>": {
+      "prose": "<arc-size> can be large or small, indicating that the larger or smaller, respectively, of the two possible arcs must be chosen. If omitted, this defaults to small.",
       "value": "large | small"
+    },
+    "<shape()>": {
+      "value": "shape( <'fill-rule'>? from <coordinate-pair>, <shape-command>#)"
     }
   }
 }

package/css-shapes.json

@@ -52,11 +52,8 @@
   },
   "descriptors": {},
   "valuespaces": {
-    "<basic-shape-rect>": {
-      "value": "<inset()> | <rect()> | <xywh()>"
-    },
-    "<shape-box>": {
-      "value": "<box> | margin-box"
+    "<basic-shape>": {
+      "prose": "The <basic-shape> type can be specified using basic shape functions. When using this syntax to define shapes, the reference box is defined by each property that uses <basic-shape> values. The coordinate system for the shape has its origin on the top-left corner of the reference box with the x-axis running to the right and the y-axis running downwards. All the lengths expressed in percentages are resolved from the used dimensions of the reference box."
     },
     "<inset()>": {
       "value": "inset( <length-percentage>{1,4} [ round <'border-radius'> ]? )"
@@ -80,8 +77,13 @@
       "value": "path( [<'fill-rule'>,]? <string> )"
     },
     "<shape-radius>": {
-      "value": "<length-percentage> | closest-side | farthest-side",
-      "prose": "Defines a radius for a circle or ellipse. If omitted it defaults to closest-side. closest-side uses the length from the center of the shape to the closest side of the reference box. For circles, this is the closest side in any dimension. For ellipses, this is the closest side in the radius dimension. farthest-side uses the length from the center of the shape to the farthest side of the reference box. For circles, this is the farthest side in any dimension. For ellipses, this is the farthest side in the radius dimension."
+      "value": "<length-percentage> | closest-side | farthest-side"
+    },
+    "<basic-shape-rect>": {
+      "value": "<inset()> | <rect()> | <xywh()>"
+    },
+    "<shape-box>": {
+      "value": "<box> | margin-box"
     }
   }
 }

package/css-size-adjust.json

@@ -21,9 +21,5 @@
     }
   },
   "descriptors": {},
-  "valuespaces": {
-    "<percentage>": {
-      "prose": "When displaying on a small device, renderers must not do size adjustment but instead the computed value of font-size must be multiplied by this percentage. Negative values are invalid."
-    }
-  }
+  "valuespaces": {}
 }

package/css-sizing.json

@@ -119,9 +119,5 @@
     }
   },
   "descriptors": {},
-  "valuespaces": {
-    "<fit-content()>": {
-      "value": "fit-content(<length-percentage>)"
-    }
-  }
+  "valuespaces": {}
 }

package/css-syntax.json

@@ -6,14 +6,105 @@
   "properties": {},
   "descriptors": {},
   "valuespaces": {
-    "<an+b>": {
-      "value": "odd | even | <integer> | <n-dimension> | '+'? n | -n | <ndashdigit-dimension> | '+'? <ndashdigit-ident> | <dashndashdigit-ident> | <n-dimension> <signed-integer> | '+'? n <signed-integer> | -n <signed-integer> | <ndash-dimension> <signless-integer> | '+'? n- <signless-integer> | -n- <signless-integer> | <n-dimension> ['+' | '-'] <signless-integer> '+'? n ['+' | '-'] <signless-integer> | -n ['+' | '-'] <signless-integer>"
+    "<ident-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
     },
-    "<urange>": {
-      "value": "u '+' <ident-token> '?'* | u <dimension-token> '?'* | u <number-token> '?'* | u <number-token> <dimension-token> | u <number-token> <number-token> | u '+' '?'+"
+    "<function-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<at-keyword-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<hash-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<string-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<bad-string-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<url-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<bad-url-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<delim-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<number-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<percentage-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<dimension-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<whitespace-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<CDO-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<CDC-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<colon-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<semicolon-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<comma-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<[-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<]-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<(-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<)-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<{-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
+    },
+    "<}-token>": {
+      "prose": "The output of tokenization step is a stream of zero or more of the following tokens: <ident-token>, <function-token>, <at-keyword-token>, <hash-token>, <string-token>, <bad-string-token>, <url-token>, <bad-url-token>, <delim-token>, <number-token>, <percentage-token>, <dimension-token>, <whitespace-token>, <CDO-token>, <CDC-token>, <colon-token>, <semicolon-token>, <comma-token>, <[-token>, <]-token>, <(-token>, <)-token>, <{-token>, and <}-token>."
     },
     "<EOF-token>": {
       "prose": "A conceptual token representing the end of the list of tokens. Whenever the list of tokens is empty, the next input token is always an <EOF-token>."
+    },
+    "<urange>": {
+      "prose": "Some constructs, such as the unicode-range descriptor for the @font-face rule, need a way to describe one or more unicode code points. The <urange> production represents a range of one or more unicode code points.",
+      "value": "u '+' <ident-token> '?'* | u <dimension-token> '?'* | u <number-token> '?'* | u <number-token> <dimension-token> | u <number-token> <number-token> | u '+' '?'+"
+    },
+    "<style-block>": {
+      "prose": "The <style-block> production represents the contents of a style rule’s block. It may only be used in grammars as the sole value in a block, and represents that the contents of the block must be parsed using the consume a style block’s contents algorithm."
+    },
+    "<declaration-list>": {
+      "prose": "The <declaration-list> production represents a list of declarations. It may only be used in grammars as the sole value in a block, and represents that the contents of the block must be parsed using the consume a list of declarations algorithm."
+    },
+    "<rule-list>": {
+      "prose": "Similarly, the <rule-list> production represents a list of rules, and may only be used in grammars as the sole value in a block. It represents that the contents of the block must be parsed using the consume a list of rules algorithm."
+    },
+    "<stylesheet>": {
+      "prose": "Finally, the <stylesheet> production represents a list of rules. It is identical to <rule-list>, except that blocks using it default to accepting all rules that aren’t otherwise limited to a particular context."
+    },
+    "<declaration-value>": {
+      "prose": "The <declaration-value> production matches any sequence of one or more tokens, so long as the sequence does not contain <bad-string-token>, <bad-url-token>, unmatched <)-token>, <]-token>, or <}-token>, or top-level <semicolon-token> tokens or <delim-token> tokens with a value of \"!\". It represents the entirety of what a valid declaration can have as its value."
+    },
+    "<any-value>": {
+      "prose": "The <any-value> production is identical to <declaration-value>, but also allows top-level <semicolon-token> tokens and <delim-token> tokens with a value of \"!\". It represents the entirety of what valid CSS can be in any context."
+    },
+    "<an+b>": {
+      "value": "odd | even | <integer> | <n-dimension> | '+'? n | -n | <ndashdigit-dimension> | '+'? <ndashdigit-ident> | <dashndashdigit-ident> | <n-dimension> <signed-integer> | '+'? n <signed-integer> | -n <signed-integer> | <ndash-dimension> <signless-integer> | '+'? n- <signless-integer> | -n- <signless-integer> | <n-dimension> ['+' | '-'] <signless-integer> | '+'? n ['+' | '-'] <signless-integer> | -n ['+' | '-'] <signless-integer>"
     }
   }
 }

package/css-text-4.json

@@ -486,17 +486,8 @@
   },
   "descriptors": {},
   "valuespaces": {
-    "<auto()>": {
-      "value": "auto(<lang>)"
-    },
-    "<length-percentages>": {
-      "prose": "Specifies extra spacing in addition to the intrinsic inter-word spacing defined by the font."
-    },
-    "<length>": {
-      "prose": "Specifies additional spacing between typographic character units. Values may be negative, but there may be implementation-dependent limits."
-    },
-    "<percentage>": {
-      "prose": "Gives the amount of the indent as a percentage of the block container’s own logical width. Percentages must be treated as 0 for the purpose of calculating intrinsic size contributions, but are always resolved normally when performing layout."
+    "<lang>": {
+      "prose": "<lang> must be a valid CSS <ident> or <string>. It represents an IETF BCP 47 language range (see [BCP47]). If the UA does not support word-boundary detection for all languages represented by the specified range, that specified value is invalid (and will cause the declaration to be ignored)."
     }
   }
 }

package/css-text.json

@@ -245,12 +245,5 @@
     }
   },
   "descriptors": {},
-  "valuespaces": {
-    "<length>": {
-      "prose": "Specifies extra spacing in addition to the intrinsic inter-word spacing defined by the font."
-    },
-    "<percentage>": {
-      "prose": "Gives the amount of the indent as a percentage of the block container’s own logical width. Percentages must be treated as 0 for the purpose of calculating intrinsic size contributions, but are always resolved normally when performing layout."
-    }
-  }
+  "valuespaces": {}
 }

package/css-transforms-2.json

@@ -109,6 +109,9 @@
   },
   "descriptors": {},
   "valuespaces": {
+    "<transform-function>": {
+      "prose": "The value of the transform property is a list of <transform-function>. The set of allowed transform functions is given below. Wherever <angle> is used in this specification, a <number> that is equal to zero is also allowed, which is treated the same as an angle of zero degrees. A percentage for horizontal translations is relative to the width of the reference box. A percentage for vertical translations is relative to the height of the reference box. A percentage in a scale function is equivalent to a number, and serializes as a number in specified values. For example, scale3d(50%, 100%, 150%) serializes as scale3d(0.5, 1, 1.5)."
+    },
     "<scale()>": {
       "value": "scale( [ <number> | <percentage> ]#{1,2} )"
     },

package/css-transforms.json

@@ -51,8 +51,8 @@
   },
   "descriptors": {},
   "valuespaces": {
-    "<transform-list>": {
-      "value": "<transform-function>+"
+    "<transform-function>": {
+      "prose": "The value of the transform property is a list of <transform-function>. The set of allowed transform functions is given below. In the following functions, a <zero> behaves the same as 0deg (\"unitless 0\" angles are preserved for legacy compat). A percentage for horizontal translations is relative to the width of the reference box. A percentage for vertical translations is relative to the height of the reference box."
     },
     "<matrix()>": {
       "value": "matrix( <number>#{6} )"
@@ -86,6 +86,9 @@
     },
     "<skewY()>": {
       "value": "skewY( [ <angle> | <zero> ] )"
+    },
+    "<transform-list>": {
+      "value": "<transform-function>+"
     }
   }
 }

package/css-ui.json

@@ -288,17 +288,23 @@
   },
   "descriptors": {},
   "valuespaces": {
-    "<compat-auto>": {
-      "value": "searchfield | textarea | push-button | slider-horizontal | checkbox | radio | square-button | menulist | listbox | meter | progress-bar | button"
+    "<outline-line-style>": {
+      "prose": "<outline-line-style> accepts the same values as <line-style> (CSS Backgrounds 3 § 3.2 Line Patterns: the border-style properties) with the same meaning, except that hidden is not a legal outline style. In addition, the outline-style property accepts the value auto. The auto value permits the user agent to render a custom outline style, typically a style which is either a user interface default for the platform, or perhaps a style that is richer than can be described in detail in CSS, e.g. a rounded edge outline with semi-translucent outer pixels that appears to glow. As such, this specification does not define how the outline-color and outline-width are incorporated or used (if at all) when rendering auto style outlines. User agents may treat auto as solid."
     },
-    "<compat-special>": {
-      "value": "textfield | menulist-button"
+    "<url-set>": {
+      "prose": "<url-set> is a limited version of image-set(), where only <url> and <url-set> can be used in the part of the <image-set-option> sub-production which would normally allow <image>."
     },
     "<id>": {
       "prose": "The <id> value is an ID selector [SELECT]. In response to directional navigation input corresponding to the property, the focus is navigated to the first element in tree order matching the selector. If this refers to the currently focused element, the directional navigation input respective to the nav- property is ignored — there is no need to refocus the same element. If no element matches the selector, the user agent automatically determines which element to navigate the focus to. If the focus is navigated to an element that was not otherwise focusable, it becomes focusable only as the result of this directional navigation, and the :focus pseudo-class matches the element while it is focused as such."
     },
     "<target-name>": {
       "prose": "The <target-name> parameter indicates the target frame for the focus navigation. It is a <string> and it MUST NOT start with the underscore \"_\" character. Error handling: if it does start with an underscore, \"_parent\" navigates to the parent frame, \"_root\" is treated as root, and other values navigate to a frame by that name if it exists. If the specified target frame does not exist, the parameter will be treated as the keyword current, which means to simply use the frame that the element is in. The keyword root indicates that the user agent should target the full window."
+    },
+    "<compat-auto>": {
+      "value": "searchfield | textarea | push-button | slider-horizontal | checkbox | radio | square-button | menulist | listbox | meter | progress-bar | button"
+    },
+    "<compat-special>": {
+      "value": "textfield | menulist-button"
     }
   }
 }

package/css-values-5.json

@@ -6,9 +6,19 @@
   "properties": {},
   "descriptors": {},
   "valuespaces": {
+    "<toggle()>": {
+      "prose": "The toggle() expression allows descendant elements to cycle over a list of values instead of inheriting the same value."
+    },
+    "<toggle-value>": {
+      "prose": "where <toggle-value> is any CSS value that is valid where the expression is placed. If any of the values inside are not valid, then the entire toggle() expression is invalid. The toggle() expression may be used as the value of any property, but must be the only component in that property’s value."
+    },
     "<attr()>": {
+      "prose": "The attr() function substitutes the value of an attribute on an element into a property, similar to how the var() function substitutes a custom property value into a function.",
       "value": "attr( <q-name> <attr-type>? , <declaration-value>?)"
     },
+    "<dimension-unit>": {
+      "prose": "The <dimension-unit> production matches a literal \"%\" character (that is, a <delim-token> with a value of \"%\") or an ident whose value is any of the CSS units for <length>, <angle>, <time>, <frequency>, or <flex> values (such as px or ms)."
+    },
     "<attr-type>": {
       "value": "string | url | ident | color | number | percentage | length | angle | time | frequency | flex | <dimension-unit>"
     }

package/css-values.json

@@ -6,27 +6,144 @@
   "properties": {},
   "descriptors": {},
   "valuespaces": {
-    "<url>": {
-      "value": "url( <string> <url-modifier>* ) | src( <string> <url-modifier>* )"
+    "<mix()>": {
+      "prose": "Interpolation of two values can be represented by the mix() functional notation, whose syntax is defined as follows:"
+    },
+    "<start-value>": {
+      "prose": "The value at the “start” (0%) of the interpolation range."
+    },
+    "<end-value>": {
+      "prose": "The value at the “end” (100%) of the interpolation range."
+    },
+    "<ident>": {
+      "prose": "CSS identifiers, generically denoted by <ident>, consist of a sequence of characters conforming to the <ident-token> grammar. [CSS-SYNTAX-3] Identifiers cannot be quoted; otherwise they would be interpreted as strings. CSS properties accept two classes of identifiers: pre-defined keywords and author-defined identifiers."
+    },
+    "<custom-ident>": {
+      "prose": "Some properties accept arbitrary author-defined identifiers as a component value. This generic data type is denoted by <custom-ident>, and represents any valid CSS identifier that would not be misinterpreted as a pre-defined keyword in that property’s value definition. Such identifiers are fully case-sensitive (meaning they’re compared using the \"identical to\" operation), even in the ASCII range (e.g. example and EXAMPLE are two different, unrelated user-defined identifiers)."
+    },
+    "<dashed-ident>": {
+      "prose": "The <dashed-ident> production is a <custom-ident>, with all the case-sensitivity that implies, with the additional restriction that it must start with two dashes (U+002D HYPHEN-MINUS)."
+    },
+    "<string>": {
+      "prose": "Strings are denoted by <string>. When written literally, they consist of a sequence of characters delimited by double quotes or single quotes, corresponding to the <string-token> production in the CSS Syntax Module [CSS-SYNTAX-3]."
+    },
+    "<url()>": {
+      "prose": "Typically, a <url> is written with the url() or src() functional notations:"
+    },
+    "<src()>": {
+      "prose": "Typically, a <url> is written with the url() or src() functional notations:"
+    },
+    "<url-modifier>": {
+      "prose": "The url() function supports specifying additional <url-modifier>s, which change the meaning or the interpretation of the URL somehow. A <url-modifier> is either an <ident> or a functional notation."
+    },
+    "<zero>": {
+      "prose": "The value <zero> represents a literal number with the value 0. Expressions that merely evaluate to a <number> with the value 0 (for example, calc(0)) do not match <zero>; only literal <number-token>s do."
+    },
+    "<dimension>": {
+      "prose": "The general term dimension refers to a number with a unit attached to it; and is denoted by <dimension>."
+    },
+    "<length-percentage>": {
+      "value": "[ <length> | <percentage> ]"
+    },
+    "<frequency-percentage>": {
+      "value": "[ <frequency> | <percentage> ]"
+    },
+    "<angle-percentage>": {
+      "value": "[ <angle> | <percentage> ]"
+    },
+    "<time-percentage>": {
+      "value": "[ <time> | <percentage> ]"
     },
     "<ratio>": {
+      "prose": "Ratio values are denoted by <ratio>, and represent the ratio of two numeric values. It most often represents an aspect ratio, relating a width (first) to a height (second).",
       "value": "<number [0,∞]> [ / <number [0,∞]> ]?"
     },
-    "<position>": {
-      "value": "[ [ left | center | right ] || [ top | center | bottom ] | [ left | center | right | <length-percentage> ] [ top | center | bottom | <length-percentage> ]? | [ [ left | right ] <length-percentage> ] && [ [ top | bottom ] <length-percentage> ] ]"
+    "<angle>": {
+      "prose": "Angle values are <dimension>s denoted by <angle>. The angle unit identifiers are:"
+    },
+    "<time>": {
+      "prose": "Time values are dimensions denoted by <time>. The time unit identifiers are:"
+    },
+    "<frequency>": {
+      "prose": "Frequency values are dimensions denoted by <frequency>. The frequency unit identifiers are:"
+    },
+    "<resolution>": {
+      "prose": "Resolution units are dimensions denoted by <resolution>. The resolution unit identifiers are:"
     },
     "<calc()>": {
+      "prose": "The calc() function is a math function that allows basic arithmetic to be performed on numerical values, using addition (+), subtraction (-), multiplication (*), division (/), and parentheses.",
       "value": "calc( <calc-sum> )"
     },
     "<min()>": {
+      "prose": "The min() or max() functions contain one or more comma-separated calculations, and represent the smallest (most negative) or largest (most positive) of them, respectively.",
       "value": "min( <calc-sum># )"
     },
     "<max()>": {
+      "prose": "The min() or max() functions contain one or more comma-separated calculations, and represent the smallest (most negative) or largest (most positive) of them, respectively.",
       "value": "max( <calc-sum># )"
     },
     "<clamp()>": {
+      "prose": "The clamp() function takes three calculations—a minimum value, a central value, and a maximum value—and represents its central calculation, clamped according to its min and max calculations, favoring the min calculation if it conflicts with the max. (That is, given clamp(MIN, VAL, MAX), it represents exactly the same value as max(MIN, min(VAL, MAX))).",
       "value": "clamp( <calc-sum>#{3} )"
     },
+    "<round(<rounding-strategy>?, A, B)>": {
+      "prose": "The round(<rounding-strategy>?, A, B) function contains an optional rounding strategy, and two calculations A and B, and returns the value of A, rounded according to the rounding strategy, to the nearest integer multiple of B either above or below A. The argument calculations can resolve to any <number>, <dimension>, or <percentage>, but must have the same type, or else the function is invalid; the result will have the same type as the arguments."
+    },
+    "<rounding-strategy>": {
+      "prose": "If A is exactly equal to an integer multiple of B, round() resolves to A exactly (preserving whether A is 0⁻ or 0⁺, if relevant). Otherwise, there are two integer multiples of B that are potentially \"closest\" to A, lower B which is closer to −∞ and upper B which is closer to +∞. The following <rounding-strategy>s dictate how to choose between them:",
+      "value": "nearest | up | down | to-zero"
+    },
+    "<mod(A, B)>": {
+      "prose": "The modulus functions mod(A, B) and rem(A, B) similarly contain two calculations A and B, and return the difference between A and the nearest integer multiple of B either above or below A. The argument calculations can resolve to any <number>, <dimension>, or <percentage>, but must have the same type, or else the function is invalid; the result will have the same type as the arguments."
+    },
+    "<rem(A, B)>": {
+      "prose": "The modulus functions mod(A, B) and rem(A, B) similarly contain two calculations A and B, and return the difference between A and the nearest integer multiple of B either above or below A. The argument calculations can resolve to any <number>, <dimension>, or <percentage>, but must have the same type, or else the function is invalid; the result will have the same type as the arguments."
+    },
+    "<sin(A)>": {
+      "prose": "The sin(A), cos(A), and tan(A) functions all contain a single calculation which must resolve to either a <number> or an <angle>, and compute their corresponding function by interpreting the result of their argument as radians. (That is, sin(45deg), sin(.125turn), and sin(3.14159 / 4) all represent the same value, approximately .707.) They all represent a <number>; sin() and cos() will always return a number between −1 and 1, while tan() can return any number between −∞ and +∞. (See § 10.9 Type Checking for details on how math functions handle ∞.)"
+    },
+    "<cos(A)>": {
+      "prose": "The sin(A), cos(A), and tan(A) functions all contain a single calculation which must resolve to either a <number> or an <angle>, and compute their corresponding function by interpreting the result of their argument as radians. (That is, sin(45deg), sin(.125turn), and sin(3.14159 / 4) all represent the same value, approximately .707.) They all represent a <number>; sin() and cos() will always return a number between −1 and 1, while tan() can return any number between −∞ and +∞. (See § 10.9 Type Checking for details on how math functions handle ∞.)"
+    },
+    "<tan(A)>": {
+      "prose": "The sin(A), cos(A), and tan(A) functions all contain a single calculation which must resolve to either a <number> or an <angle>, and compute their corresponding function by interpreting the result of their argument as radians. (That is, sin(45deg), sin(.125turn), and sin(3.14159 / 4) all represent the same value, approximately .707.) They all represent a <number>; sin() and cos() will always return a number between −1 and 1, while tan() can return any number between −∞ and +∞. (See § 10.9 Type Checking for details on how math functions handle ∞.)"
+    },
+    "<asin(A)>": {
+      "prose": "The asin(A), acos(A), and atan(A) functions are the \"arc\" or \"inverse\" trigonometric functions, representing the inverse function to their corresponding \"normal\" trig functions. All of them contain a single calculation which must resolve to a <number>, and compute their corresponding function, interpreting their result as a number of radians, representing an <angle>. The angle returned by asin() must be normalized to the range [-90deg, 90deg]; the angle returned by acos() to the range [0deg, 180deg]; and the angle returned by atan() to the range [-90deg, 90deg]."
+    },
+    "<acos(A)>": {
+      "prose": "The asin(A), acos(A), and atan(A) functions are the \"arc\" or \"inverse\" trigonometric functions, representing the inverse function to their corresponding \"normal\" trig functions. All of them contain a single calculation which must resolve to a <number>, and compute their corresponding function, interpreting their result as a number of radians, representing an <angle>. The angle returned by asin() must be normalized to the range [-90deg, 90deg]; the angle returned by acos() to the range [0deg, 180deg]; and the angle returned by atan() to the range [-90deg, 90deg]."
+    },
+    "<atan(A)>": {
+      "prose": "The asin(A), acos(A), and atan(A) functions are the \"arc\" or \"inverse\" trigonometric functions, representing the inverse function to their corresponding \"normal\" trig functions. All of them contain a single calculation which must resolve to a <number>, and compute their corresponding function, interpreting their result as a number of radians, representing an <angle>. The angle returned by asin() must be normalized to the range [-90deg, 90deg]; the angle returned by acos() to the range [0deg, 180deg]; and the angle returned by atan() to the range [-90deg, 90deg]."
+    },
+    "<atan2(A, B)>": {
+      "prose": "The atan2(A, B) function contains two comma-separated calculations, A and B. A and B can resolve to any <number>, <dimension>, or <percentage>, but must have the same type, or else the function is invalid. The function returns the <angle> between the positive X-axis and the point (B,A). The returned angle must be normalized to the interval (-180deg, 180deg] (that is, greater than -180deg, and less than or equal to 180deg)."
+    },
+    "<pow(A, B)>": {
+      "prose": "The pow(A, B) function contains two comma-separated calculations A and B, both of which must resolve to <number>s, and returns the result of raising A to the power of B, returning the value as a <number>."
+    },
+    "<sqrt(A)>": {
+      "prose": "The sqrt(A) function contains a single calculation which must resolve to a <number>, and returns the square root of the value as a <number>. (sqrt(X) and pow(X, .5) are basically equivalent, differing only in some error-handling; sqrt() is a common enough function that it is provided as a convenience.)"
+    },
+    "<hypot(A, …)>": {
+      "prose": "The hypot(A, …) function contains one or more comma-separated calculations, and returns the length of an N-dimensional vector with components equal to each of the calculations. (That is, the square root of the sum of the squares of its arguments.) The argument calculations can resolve to any <number>, <dimension>, or <percentage>, but must have the same type, or else the function is invalid; the result will have the same type as the arguments."
+    },
+    "<log(A, B?)>": {
+      "prose": "The log(A, B?) function contains one or two calculations (representing the value to be logarithmed, and the base of the logarithm, defaulting to e), which must resolve to <number>s, and returns the logarithm base B of the value A, as a <number>."
+    },
+    "<exp(A)>": {
+      "prose": "The exp(A) function contains one calculation which must resolve to a <number>, and returns the same value as pow(e, A) as a <number>."
+    },
+    "<abs(A)>": {
+      "prose": "The abs(A) function contains one calculation A, and returns the absolute value of A, as the same type as the input: if A’s numeric value is positive or 0⁺, just A again; otherwise -1 * A."
+    },
+    "<sign(A)>": {
+      "prose": "The sign(A) function contains one calculation A, and returns -1 if A’s numeric value is negative, +1 if A’s numeric value is positive, 0⁺ if A’s numeric value is 0⁺, and 0⁻ if A’s numeric value is 0⁻."
+    },
+    "<quirky-length>": {
+      "prose": "When CSS is being parsed in quirks mode, <quirky-length> is a type of <length> that is only valid in certain properties:"
+    },
     "<round()>": {
       "value": "round( <rounding-strategy>?, <calc-sum>, <calc-sum> )"
     },
@@ -89,27 +206,6 @@
     },
     "<calc-constant>": {
       "value": "e | pi | infinity | -infinity | NaN"
-    },
-    "<rounding-strategy>": {
-      "value": "nearest | up | down | to-zero"
-    },
-    "<start-value>": {
-      "prose": "The value at the “start” (0%) of the interpolation range."
-    },
-    "<end-value>": {
-      "prose": "The value at the “end” (100%) of the interpolation range."
-    },
-    "<length-percentage>": {
-      "value": "[ <length> | <percentage> ]"
-    },
-    "<frequency-percentage>": {
-      "value": "[ <frequency> | <percentage> ]"
-    },
-    "<angle-percentage>": {
-      "value": "[ <angle> | <percentage> ]"
-    },
-    "<time-percentage>": {
-      "value": "[ <time> | <percentage> ]"
     }
   }
 }

package/css-variables.json

@@ -6,6 +6,9 @@
   "properties": {},
   "descriptors": {},
   "valuespaces": {
+    "<custom-property-name>": {
+      "prose": "A custom property is any property whose name starts with two dashes (U+002D HYPHEN-MINUS), like --foo. The <custom-property-name> production corresponds to this: it’s defined as any <dashed-ident> (a valid identifier that starts with two dashes), except -- itself, which is reserved for future use by CSS. Custom properties are solely for use by authors and users; CSS will never give them a meaning beyond what is presented here."
+    },
     "<var()>": {
       "value": "var( <custom-property-name> , <declaration-value>? )"
     }

package/fill-stroke.json

@@ -428,9 +428,6 @@
     },
     "<svg-paint>": {
       "value": "child | child( <integer> )"
-    },
-    "<child()>": {
-      "value": "child(<integer>)"
     }
   }
 }