@webref/css 6.16.0 → 6.17.0

package/css-anchor-position.json

@@ -78,9 +78,9 @@
     {
       "name": "position-anchor",
       "href": "https://drafts.csswg.org/css-anchor-position-1/#propdef-position-anchor",
-      "value": "auto | <anchor-element>",
+      "value": "auto | <anchor-name>",
       "initial": "auto",
-      "appliesTo": "absolutely positioned elements",
+      "appliesTo": "absolutely positioned boxes",
       "inherited": "no",
       "percentages": "n/a",
       "computedValue": "as specified",
@@ -89,10 +89,17 @@
       "values": [
         {
           "name": "auto",
-          "prose": "Its values are identical to the <anchor-element> term in anchor() and anchor-size(), except that the auto value is equivalent to omitting the <anchor-element> in anchor() (referring to the implicit anchor element, if one exists).",
+          "prose": "Use the implicit anchor element if it exists; otherwise the box has no default anchor element.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-anchor-auto",
           "type": "value",
           "value": "auto"
+        },
+        {
+          "name": "<anchor-name>",
+          "prose": "The target anchor element selected by the specified <anchor-name> is the box’s default anchor element.",
+          "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-anchor-anchor-name",
+          "type": "value",
+          "value": "<anchor-name>"
         }
       ],
       "styleDeclaration": [
@@ -105,7 +112,7 @@
       "href": "https://drafts.csswg.org/css-anchor-position-1/#propdef-position-area",
       "value": "none | <position-area>",
       "initial": "none",
-      "appliesTo": "positioned elements with a default anchor element",
+      "appliesTo": "positioned boxes with a default anchor box",
       "inherited": "no",
       "percentages": "n/a",
       "computedValue": "as specified",
@@ -121,7 +128,7 @@
         },
         {
           "name": "<position-area>",
-          "prose": "If the element does not have a default anchor element, or is not an absolutely-positioned element, this value has no effect. Otherwise, it has the following effects: The property selects a region of the position-area grid, and makes that the element’s containing block. See § 3.1.1 Resolving <position-area>s for details. Note: This means that the inset properties specify offsets from the position-area, and some property values, like max-height: 100%, will be relative to the position-area as well. The normal value for the self-alignment properties behaves as either start, end, or anchor-center, depending on the positioning of the region, to give a good default alignment for the positioned element. Again, see § 3.1.1 Resolving <position-area>s for details. Any auto inset properties resolve to 0. The element is not considered to be in a legacy alignment mode in either axis.",
+          "prose": "If the box does not have a default anchor box, or is not an absolutely positioned box, this value has no effect. Otherwise, it has the following effects: The property selects a region of the position-area grid, and makes that the box’s containing block. See § 3.1.1 Resolving <position-area>s for details. Note: This means that the inset properties specify offsets from the position-area, and some property values, like max-height: 100%, will be relative to the position-area as well. The normal value for the self-alignment properties behaves as either start, end, or anchor-center, depending on the positioning of the region, to give a good default alignment for the positioned box. Again, see § 3.1.1 Resolving <position-area>s for details. Any auto inset properties resolve to 0. The box is not considered to be in a legacy alignment mode in either axis.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-position-area",
           "type": "value",
           "value": "<position-area>"
@@ -166,7 +173,7 @@
       "values": [
         {
           "name": "anchor-center",
-          "prose": "The new anchor-center value makes this case extremely simple: if the positioned element has a default anchor element, then it is aligned so as to center itself over the default anchor element in the relevant axis.",
+          "prose": "The new anchor-center value makes this case extremely simple: if the positioned box has a default anchor box, then it is centered (insofar as possible) over the default anchor box in the relevant axis.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-justify-self-anchor-center",
           "type": "value",
           "value": "anchor-center"
@@ -183,7 +190,7 @@
       "values": [
         {
           "name": "anchor-center",
-          "prose": "The new anchor-center value makes this case extremely simple: if the positioned element has a default anchor element, then it is aligned so as to center itself over the default anchor element in the relevant axis.",
+          "prose": "The new anchor-center value makes this case extremely simple: if the positioned box has a default anchor box, then it is centered (insofar as possible) over the default anchor box in the relevant axis.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-justify-self-anchor-center",
           "type": "value",
           "value": "anchor-center"
@@ -200,7 +207,7 @@
       "values": [
         {
           "name": "anchor-center",
-          "prose": "The new anchor-center value makes this case extremely simple: if the positioned element has a default anchor element, then it is aligned so as to center itself over the default anchor element in the relevant axis.",
+          "prose": "The new anchor-center value makes this case extremely simple: if the positioned box has a default anchor box, then it is centered (insofar as possible) over the default anchor box in the relevant axis.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-justify-self-anchor-center",
           "type": "value",
           "value": "anchor-center"
@@ -217,7 +224,7 @@
       "values": [
         {
           "name": "anchor-center",
-          "prose": "The new anchor-center value makes this case extremely simple: if the positioned element has a default anchor element, then it is aligned so as to center itself over the default anchor element in the relevant axis.",
+          "prose": "The new anchor-center value makes this case extremely simple: if the positioned box has a default anchor box, then it is centered (insofar as possible) over the default anchor box in the relevant axis.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-justify-self-anchor-center",
           "type": "value",
           "value": "anchor-center"
@@ -233,7 +240,7 @@
       "href": "https://drafts.csswg.org/css-anchor-position-1/#propdef-position-visibility",
       "value": "always | [ anchors-valid || anchors-visible || no-overflow ]",
       "initial": "anchors-visible",
-      "appliesTo": "absolutely-positioned elements",
+      "appliesTo": "absolutely positioned boxes",
       "inherited": "no",
       "percentages": "n/a",
       "computedValue": "as specified",
@@ -242,28 +249,28 @@
       "values": [
         {
           "name": "always",
-          "prose": "This property has no effect. (The element is displayed without regard for its anchors or its overflowing status.)",
+          "prose": "This property has no effect. (The box is displayed without regard for its anchors or its overflowing status.)",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-visibility-always",
           "type": "value",
           "value": "always"
         },
         {
           "name": "anchors-valid",
-          "prose": "If any of the element’s required anchor references do not resolve to a target anchor element, the element is strongly hidden. What is a required anchor reference? anchor() functions that don’t have a fallback value; the default anchor *sometimes*? Need more detail here. Any anchors are missing, or all anchors are missing? I can see use-cases for either, potentially. Do we want to make a decision here, or make it controllable somehow?",
+          "prose": "If any of the box’s required anchor references do not resolve to a target anchor element, the box is strongly hidden. What is a required anchor reference? anchor() functions that don’t have a fallback value; the default anchor *sometimes*? Need more detail here. Any anchors are missing, or all anchors are missing? I can see use-cases for either, potentially. Do we want to make a decision here, or make it controllable somehow?",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-visibility-anchors-valid",
           "type": "value",
           "value": "anchors-valid"
         },
         {
           "name": "anchors-visible",
-          "prose": "If the element has a default anchor element but the anchor element is clipped by intervening elements, this element is also strongly hidden.",
+          "prose": "If the box has a default anchor box but that anchor box is clipped by intervening boxes, this box is also strongly hidden.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-visibility-anchors-visible",
           "type": "value",
           "value": "anchors-visible"
         },
         {
           "name": "no-overflow",
-          "prose": "If the element overflows its inset-modified containing block, even after applying position-try, then the element is strongly hidden.",
+          "prose": "If the box overflows its inset-modified containing block even after applying position-try, then the box is strongly hidden.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-visibility-no-overflow",
           "type": "value",
           "value": "no-overflow"
@@ -357,7 +364,7 @@
       "href": "https://drafts.csswg.org/css-anchor-position-1/#propdef-position-try-fallbacks",
       "value": "none | [ [<dashed-ident> || <try-tactic>] | <'position-area'> ]#",
       "initial": "none",
-      "appliesTo": "absolutely-positioned elements",
+      "appliesTo": "absolutely positioned boxes",
       "inherited": "no",
       "percentages": "n/a",
       "computedValue": "as specified",
@@ -366,7 +373,7 @@
       "values": [
         {
           "name": "none",
-          "prose": "The property has no effect; the element’s position options list is empty.",
+          "prose": "The property has no effect; the box’s position options list is empty.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-try-fallbacks-none",
           "type": "value",
           "value": "none"
@@ -413,14 +420,14 @@
         },
         {
           "name": "<dashed-ident> || <try-tactic>",
-          "prose": "Combines the effects of the previous two options: if there is a @position-try rule with the given name, then applies its position option to the element’s base style, transforms it according to the specified <try-tactic>, and then adds the result to the element’s position options list. Otherwise, does nothing.",
+          "prose": "Combines the effects of the previous two options: if there is a @position-try rule with the given name, applies its position option to the base style, then transforms it according to the specified <try-tactic> and adds the result to the box’s position options list. Otherwise, does nothing.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-try-fallbacks-dashed-ident--try-tactic",
           "type": "value",
           "value": "<dashed-ident> || <try-tactic>"
         },
         {
           "name": "<'position-area'>",
-          "prose": "Automatically creates a position option composed solely of an position-area property with the given value.",
+          "prose": "Automatically creates a position option composed solely of a position-area property with the given value.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-try-fallbacks-position-area",
           "type": "value",
           "value": "<'position-area'>"
@@ -436,7 +443,7 @@
       "href": "https://drafts.csswg.org/css-anchor-position-1/#propdef-position-try-order",
       "value": "normal | <try-size>",
       "initial": "normal",
-      "appliesTo": "absolutely positioned elements",
+      "appliesTo": "absolutely positioned boxes",
       "inherited": "no",
       "percentages": "n/a",
       "computedValue": "as specified",
@@ -452,28 +459,28 @@
         },
         {
           "name": "most-width",
-          "prose": "For each entry in the position options list, apply a position option using that option to the element, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
+          "prose": "For each entry in the position options list, apply that position option to the box, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-try-order-most-width",
           "type": "value",
           "value": "most-width"
         },
         {
           "name": "most-height",
-          "prose": "For each entry in the position options list, apply a position option using that option to the element, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
+          "prose": "For each entry in the position options list, apply that position option to the box, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-try-order-most-height",
           "type": "value",
           "value": "most-height"
         },
         {
           "name": "most-block-size",
-          "prose": "For each entry in the position options list, apply a position option using that option to the element, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
+          "prose": "For each entry in the position options list, apply that position option to the box, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-try-order-most-block-size",
           "type": "value",
           "value": "most-block-size"
         },
         {
           "name": "most-inline-size",
-          "prose": "For each entry in the position options list, apply a position option using that option to the element, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
+          "prose": "For each entry in the position options list, apply that position option to the box, and find the specified inset-modified containing block size that results from those styles. Stably sort the position options list according to this size, with the largest coming first.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-try-order-most-inline-size",
           "type": "value",
           "value": "most-inline-size"
@@ -504,7 +511,7 @@
   "atrules": [
     {
       "name": "@position-try",
-      "prose": "The @position-try rule defines a position option with a given name, specifying one or more sets of positioning properties that will be applied to an element via position-try-fallbacks,",
+      "prose": "The @position-try rule defines a position option with a given name, specifying one or more sets of positioning properties that can be applied to a box via position-try-fallbacks,",
       "href": "https://drafts.csswg.org/css-anchor-position-1/#at-ruledef-position-try",
       "descriptors": [],
       "value": "@position-try <dashed-ident> { <declaration-list> }"
@@ -520,175 +527,175 @@
       "values": [
         {
           "name": "start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-start",
           "type": "value",
           "value": "start"
         },
         {
           "name": "end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-end",
           "type": "value",
           "value": "end"
         },
         {
           "name": "self-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-self-start",
           "type": "value",
           "value": "self-start"
         },
         {
           "name": "self-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-self-end",
           "type": "value",
           "value": "self-end"
         },
         {
           "name": "top",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-top",
           "type": "value",
           "value": "top"
         },
         {
           "name": "bottom",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-bottom",
           "type": "value",
           "value": "bottom"
         },
         {
           "name": "left",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-left",
           "type": "value",
           "value": "left"
         },
         {
           "name": "right",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-right",
           "type": "value",
           "value": "right"
         },
         {
           "name": "y-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-y-start",
           "type": "value",
           "value": "y-start"
         },
         {
           "name": "y-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-y-end",
           "type": "value",
           "value": "y-end"
         },
         {
           "name": "y-self-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-y-self-start",
           "type": "value",
           "value": "y-self-start"
         },
         {
           "name": "y-self-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-y-self-end",
           "type": "value",
           "value": "y-self-end"
         },
         {
           "name": "x-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-x-start",
           "type": "value",
           "value": "x-start"
         },
         {
           "name": "x-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-x-end",
           "type": "value",
           "value": "x-end"
         },
         {
           "name": "x-self-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-x-self-start",
           "type": "value",
           "value": "x-self-start"
         },
         {
           "name": "x-self-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-x-self-end",
           "type": "value",
           "value": "x-self-end"
         },
         {
           "name": "block-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-block-start",
           "type": "value",
           "value": "block-start"
         },
         {
           "name": "block-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-block-end",
           "type": "value",
           "value": "block-end"
         },
         {
           "name": "block-self-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-block-self-start",
           "type": "value",
           "value": "block-self-start"
         },
         {
           "name": "block-self-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-block-self-end",
           "type": "value",
           "value": "block-self-end"
         },
         {
           "name": "inline-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-inline-start",
           "type": "value",
           "value": "inline-start"
         },
         {
           "name": "inline-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-inline-end",
           "type": "value",
           "value": "inline-end"
         },
         {
           "name": "inline-self-start",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-inline-self-start",
           "type": "value",
           "value": "inline-self-start"
         },
         {
           "name": "inline-self-end",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-inline-self-end",
           "type": "value",
           "value": "inline-self-end"
         },
         {
           "name": "center",
-          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the element’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The \"self\" logical keywords (self-start, x-self-end, etc) are identical, but refer to the element’s own writing mode.",
+          "prose": "The single corresponding row or column, depending on which axis this keyword is specifying. Like in anchor(), the plain logical keywords (start, end, etc) refer to the writing mode of the box’s containing block. The x-start/etc determine their direction in the same way, but in the specified physical axis. The self-* logical keywords (self-start, x-self-end, etc) are identical, but refer to the box’s own writing mode.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-position-area-center",
           "type": "value",
           "value": "center"
@@ -788,10 +795,10 @@
     },
     {
       "name": "anchor()",
-      "prose": "An absolutely-positioned element can use the anchor() function as a value in its inset properties to refer to the position of one or more anchor elements. The anchor() function resolves to a <length>. It is only valid to be used in the inset properties.",
+      "prose": "An absolutely positioned box can use the anchor() function as a value in its inset properties to refer to the position of one or more anchor boxes. The anchor() function resolves to a <length>. It is only valid to be used in the inset properties.",
       "href": "https://drafts.csswg.org/css-anchor-position-1/#funcdef-anchor",
       "type": "function",
-      "value": "anchor( <anchor-element>? && <anchor-side>, <length-percentage>? )",
+      "value": "anchor( <anchor-name>? && <anchor-side>, <length-percentage>? )",
       "values": [
         {
           "name": "<dashed-ident>",
@@ -802,70 +809,70 @@
         },
         {
           "name": "inside",
-          "prose": "Resolves to one of the anchor element’s sides, depending on which inset property it’s used in. inside refers to the same side as the inset property (attaching the element to the \"inside\" of the anchor), while outside refers to the opposite.",
+          "prose": "Resolves to one of the anchor box’s sides, depending on which inset property it’s used in. inside refers to the same side as the inset property (attaching the positioned box to the \"inside\" of the anchor box), while outside refers to the opposite.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-inside",
           "type": "value",
           "value": "inside"
         },
         {
           "name": "outside",
-          "prose": "Resolves to one of the anchor element’s sides, depending on which inset property it’s used in. inside refers to the same side as the inset property (attaching the element to the \"inside\" of the anchor), while outside refers to the opposite.",
+          "prose": "Resolves to one of the anchor box’s sides, depending on which inset property it’s used in. inside refers to the same side as the inset property (attaching the positioned box to the \"inside\" of the anchor box), while outside refers to the opposite.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-outside",
           "type": "value",
           "value": "outside"
         },
         {
           "name": "top",
-          "prose": "Refers to the specified side of the anchor element.",
+          "prose": "Refers to the specified side of the anchor box.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-top",
           "type": "value",
           "value": "top"
         },
         {
           "name": "right",
-          "prose": "Refers to the specified side of the anchor element.",
+          "prose": "Refers to the specified side of the anchor box.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-right",
           "type": "value",
           "value": "right"
         },
         {
           "name": "bottom",
-          "prose": "Refers to the specified side of the anchor element.",
+          "prose": "Refers to the specified side of the anchor box.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-bottom",
           "type": "value",
           "value": "bottom"
         },
         {
           "name": "left",
-          "prose": "Refers to the specified side of the anchor element.",
+          "prose": "Refers to the specified side of the anchor box.",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-left",
           "type": "value",
           "value": "left"
         },
         {
           "name": "start",
-          "prose": "Refers to one of the sides of the anchor element in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned element (for self-start and self-end) or the positioned element’s containing block (for start and end).",
+          "prose": "Refers to one of the sides of the anchor box in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned box (for self-start and self-end) or the positioned box’s containing block (for start and end).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-start",
           "type": "value",
           "value": "start"
         },
         {
           "name": "end",
-          "prose": "Refers to one of the sides of the anchor element in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned element (for self-start and self-end) or the positioned element’s containing block (for start and end).",
+          "prose": "Refers to one of the sides of the anchor box in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned box (for self-start and self-end) or the positioned box’s containing block (for start and end).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-end",
           "type": "value",
           "value": "end"
         },
         {
           "name": "self-start",
-          "prose": "Refers to one of the sides of the anchor element in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned element (for self-start and self-end) or the positioned element’s containing block (for start and end).",
+          "prose": "Refers to one of the sides of the anchor box in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned box (for self-start and self-end) or the positioned box’s containing block (for start and end).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-self-start",
           "type": "value",
           "value": "self-start"
         },
         {
           "name": "self-end",
-          "prose": "Refers to one of the sides of the anchor element in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned element (for self-start and self-end) or the positioned element’s containing block (for start and end).",
+          "prose": "Refers to one of the sides of the anchor box in the same axis as the inset property it’s used in, by resolving the keyword against the writing mode of either the positioned box (for self-start and self-end) or the positioned box’s containing block (for start and end).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-self-end",
           "type": "value",
           "value": "self-end"
@@ -887,8 +894,8 @@
       ]
     },
     {
-      "name": "<anchor-element>",
-      "href": "https://drafts.csswg.org/css-anchor-position-1/#typedef-anchor-element",
+      "name": "<anchor-name>",
+      "href": "https://drafts.csswg.org/css-anchor-position-1/#typedef-anchor-name",
       "type": "type",
       "value": "<dashed-ident>"
     },
@@ -900,10 +907,10 @@
     },
     {
       "name": "anchor-size()",
-      "prose": "An absolutely-positioned element can use the anchor-size() function in its sizing properties to refer to the size of one or more anchor elements. The anchor-size() function resolves to a <length>. It is only valid to be used in the sizing properties.",
+      "prose": "An absolutely positioned box can use the anchor-size() function in its sizing properties to refer to the size of one or more anchor boxes. The anchor-size() function resolves to a <length>. It is only valid to be used in the accepted @position-try properties.",
       "href": "https://drafts.csswg.org/css-anchor-position-1/#funcdef-anchor-size",
       "type": "function",
-      "value": "anchor-size( [ <anchor-element> || <anchor-size> ]? , <length-percentage>? )",
+      "value": "anchor-size( [ <anchor-name> || <anchor-size> ]? , <length-percentage>? )",
       "values": [
         {
           "name": "width",
@@ -921,28 +928,28 @@
         },
         {
           "name": "block",
-          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the element (for self-block and self-inline) or the writing mode of the element’s containing block (for block and inline).",
+          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the box (for self-block and self-inline) or the writing mode of the box’s containing block (for block and inline).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-size-block",
           "type": "value",
           "value": "block"
         },
         {
           "name": "inline",
-          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the element (for self-block and self-inline) or the writing mode of the element’s containing block (for block and inline).",
+          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the box (for self-block and self-inline) or the writing mode of the box’s containing block (for block and inline).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-size-inline",
           "type": "value",
           "value": "inline"
         },
         {
           "name": "self-block",
-          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the element (for self-block and self-inline) or the writing mode of the element’s containing block (for block and inline).",
+          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the box (for self-block and self-inline) or the writing mode of the box’s containing block (for block and inline).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-size-self-block",
           "type": "value",
           "value": "self-block"
         },
         {
           "name": "self-inline",
-          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the element (for self-block and self-inline) or the writing mode of the element’s containing block (for block and inline).",
+          "prose": "The logical <anchor-size> keywords (block, inline, self-block, and self-inline) map to one of the physical keywords according to either the writing mode of the box (for self-block and self-inline) or the writing mode of the box’s containing block (for block and inline).",
           "href": "https://drafts.csswg.org/css-anchor-position-1/#valdef-anchor-size-self-inline",
           "type": "value",
           "value": "self-inline"

package/css-mixins.json

@@ -63,42 +63,6 @@
       "prose": "A <dashed-function> is a functional notation whose function name starts with two dashes (U+002D HYPHEN-MINUS). Its syntax is:",
       "href": "https://drafts.csswg.org/css-mixins-1/#typedef-dashed-function",
       "type": "type"
-    },
-    {
-      "name": "<syntax-type>",
-      "href": "https://drafts.csswg.org/css-mixins-1/#typedef-syntax-type",
-      "type": "type",
-      "value": "angle | color | custom-ident | image | integer | length | length-percentage | number | percentage | resolution | string | time | url | transform-function"
-    },
-    {
-      "name": "<syntax-combinator>",
-      "href": "https://drafts.csswg.org/css-mixins-1/#typedef-syntax-combinator",
-      "type": "type",
-      "value": "'|'"
-    },
-    {
-      "name": "<syntax-multiplier>",
-      "href": "https://drafts.csswg.org/css-mixins-1/#typedef-syntax-multiplier",
-      "type": "type",
-      "value": "[ '#' | '+' ]"
-    },
-    {
-      "name": "<syntax-component-name>",
-      "href": "https://drafts.csswg.org/css-mixins-1/#typedef-syntax-component-name",
-      "type": "type",
-      "value": "'<' <syntax-type> '>' | <custom-ident>"
-    },
-    {
-      "name": "<syntax-component>",
-      "href": "https://drafts.csswg.org/css-mixins-1/#typedef-syntax-component",
-      "type": "type",
-      "value": "<syntax-component-name> <syntax-multiplier>? | '<' transform-list '>'"
-    },
-    {
-      "name": "<syntax>",
-      "href": "https://drafts.csswg.org/css-mixins-1/#typedef-syntax",
-      "type": "type",
-      "value": "'*' | <syntax-component> [ <syntax-combinator> <syntax-component> ]+"
     }
   ]
 }

package/css-pseudo.json

@@ -35,6 +35,11 @@
       "prose": "The ::selection pseudo-element represents the portion of a document that has been selected as the target or object of some possible future user-agent operation(s). It applies, for example, to selected text within an editable text field, which would be copied by a copy operation or replaced by a paste operation.",
       "href": "https://drafts.csswg.org/css-pseudo-4/#selectordef-selection"
     },
+    {
+      "name": "::search-text",
+      "prose": "The ::search-text pseudo-element represents text identified by the user agent’s find-in-page feature. Since not all UAs style matched text in ways expressible with the highlight pseudo-elements, this pseudo-element is optional to implement. How to identify the current match? [Issue #10527]",
+      "href": "https://drafts.csswg.org/css-pseudo-4/#selectordef-search-text"
+    },
     {
       "name": "::target-text",
       "prose": "The ::target-text pseudo-element represents text directly targeted by the document URL’s fragment, if any.",
@@ -50,6 +55,11 @@
       "prose": "The ::grammar-error pseudo-element represents a portion of text that has been flagged by the user agent as grammatically incorrect.",
       "href": "https://drafts.csswg.org/css-pseudo-4/#selectordef-grammar-error"
     },
+    {
+      "name": "::highlight()",
+      "value": "::highlight(<custom-ident>)",
+      "href": "https://drafts.csswg.org/css-pseudo-4/#selectordef-highlight-custom-ident"
+    },
     {
       "name": "::before",
       "prose": "Represents a styleable child pseudo-element immediately before the originating element’s actual content.",
@@ -72,19 +82,13 @@
     },
     {
       "name": "::file-selector-button",
-      "prose": "The ::file-selector-button pseudo-element targets the <button> inside an <input> element with type=file, if the UA renders such a button. It is a part-like pseudo-element.",
+      "prose": "The ::file-selector-button pseudo-element targets the <button> inside an <input> element with type=file, if the UA renders such a button. It is an element-backed pseudo-element.",
       "href": "https://drafts.csswg.org/css-pseudo-4/#selectordef-file-selector-button"
     },
     {
       "name": "::details-content",
-      "prose": "The ::details-content pseudo-element targets the additional information in a a details element that can be expanded or collapsed. It is a part-like pseudo-element.",
+      "prose": "The ::details-content pseudo-element targets the additional information in a a details element that can be expanded or collapsed. It is an element-backed pseudo-element.",
       "href": "https://drafts.csswg.org/css-pseudo-4/#selectordef-details-content"
-    },
-    {
-      "name": "::picker()",
-      "prose": "The ::picker() pseudo-element targets the popup picker of form control elements which have popup pickers, such as the select element. It is a part-like pseudo-element.",
-      "href": "https://drafts.csswg.org/css-pseudo-4/#selectordef-picker",
-      "value": "::picker( <ident>+ )"
     }
   ],
   "values": []

package/css-sizing-4.json

@@ -64,68 +64,6 @@
         "height"
       ]
     },
-    {
-      "name": "inline-size",
-      "newValues": "stretch | fit-content | contain",
-      "values": [
-        {
-          "name": "stretch",
-          "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
-          "type": "value",
-          "value": "stretch"
-        },
-        {
-          "name": "fit-content",
-          "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
-          "type": "value",
-          "value": "fit-content"
-        },
-        {
-          "name": "contain",
-          "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
-          "type": "value",
-          "value": "contain"
-        }
-      ],
-      "styleDeclaration": [
-        "inline-size",
-        "inlineSize"
-      ]
-    },
-    {
-      "name": "block-size",
-      "newValues": "stretch | fit-content | contain",
-      "values": [
-        {
-          "name": "stretch",
-          "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
-          "type": "value",
-          "value": "stretch"
-        },
-        {
-          "name": "fit-content",
-          "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
-          "type": "value",
-          "value": "fit-content"
-        },
-        {
-          "name": "contain",
-          "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
-          "type": "value",
-          "value": "contain"
-        }
-      ],
-      "styleDeclaration": [
-        "block-size",
-        "blockSize"
-      ]
-    },
     {
       "name": "min-width",
       "newValues": "stretch | fit-content | contain",
@@ -188,68 +126,6 @@
         "minHeight"
       ]
     },
-    {
-      "name": "min-inline-size",
-      "newValues": "stretch | fit-content | contain",
-      "values": [
-        {
-          "name": "stretch",
-          "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
-          "type": "value",
-          "value": "stretch"
-        },
-        {
-          "name": "fit-content",
-          "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
-          "type": "value",
-          "value": "fit-content"
-        },
-        {
-          "name": "contain",
-          "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
-          "type": "value",
-          "value": "contain"
-        }
-      ],
-      "styleDeclaration": [
-        "min-inline-size",
-        "minInlineSize"
-      ]
-    },
-    {
-      "name": "min-block-size",
-      "newValues": "stretch | fit-content | contain",
-      "values": [
-        {
-          "name": "stretch",
-          "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
-          "type": "value",
-          "value": "stretch"
-        },
-        {
-          "name": "fit-content",
-          "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
-          "type": "value",
-          "value": "fit-content"
-        },
-        {
-          "name": "contain",
-          "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
-          "type": "value",
-          "value": "contain"
-        }
-      ],
-      "styleDeclaration": [
-        "min-block-size",
-        "minBlockSize"
-      ]
-    },
     {
       "name": "max-width",
       "newValues": "stretch | fit-content | contain",
@@ -312,68 +188,6 @@
         "maxHeight"
       ]
     },
-    {
-      "name": "max-inline-size",
-      "newValues": "stretch | fit-content | contain",
-      "values": [
-        {
-          "name": "stretch",
-          "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
-          "type": "value",
-          "value": "stretch"
-        },
-        {
-          "name": "fit-content",
-          "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
-          "type": "value",
-          "value": "fit-content"
-        },
-        {
-          "name": "contain",
-          "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
-          "type": "value",
-          "value": "contain"
-        }
-      ],
-      "styleDeclaration": [
-        "max-inline-size",
-        "maxInlineSize"
-      ]
-    },
-    {
-      "name": "max-block-size",
-      "newValues": "stretch | fit-content | contain",
-      "values": [
-        {
-          "name": "stretch",
-          "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
-          "type": "value",
-          "value": "stretch"
-        },
-        {
-          "name": "fit-content",
-          "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
-          "type": "value",
-          "value": "fit-content"
-        },
-        {
-          "name": "contain",
-          "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
-          "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
-          "type": "value",
-          "value": "contain"
-        }
-      ],
-      "styleDeclaration": [
-        "max-block-size",
-        "maxBlockSize"
-      ]
-    },
     {
       "name": "aspect-ratio",
       "href": "https://drafts.csswg.org/css-sizing-4/#propdef-aspect-ratio",
@@ -619,5 +433,169 @@
   ],
   "atrules": [],
   "selectors": [],
-  "values": []
+  "values": [],
+  "warnings": [
+    {
+      "msg": "Dangling value",
+      "name": "stretch",
+      "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
+      "type": "value",
+      "value": "stretch",
+      "for": "inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "stretch",
+      "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
+      "type": "value",
+      "value": "stretch",
+      "for": "block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "stretch",
+      "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
+      "type": "value",
+      "value": "stretch",
+      "for": "min-inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "stretch",
+      "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
+      "type": "value",
+      "value": "stretch",
+      "for": "min-block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "stretch",
+      "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
+      "type": "value",
+      "value": "stretch",
+      "for": "max-inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "stretch",
+      "prose": "Applies stretch-fit sizing, attempting to match the size of the box’s margin box to the size of its containing block. See § 6.1 Stretch-fit Sizing: filling the containing block.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-stretch",
+      "type": "value",
+      "value": "stretch",
+      "for": "max-block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "fit-content",
+      "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
+      "type": "value",
+      "value": "fit-content",
+      "for": "inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "fit-content",
+      "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
+      "type": "value",
+      "value": "fit-content",
+      "for": "block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "fit-content",
+      "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
+      "type": "value",
+      "value": "fit-content",
+      "for": "min-inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "fit-content",
+      "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
+      "type": "value",
+      "value": "fit-content",
+      "for": "min-block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "fit-content",
+      "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
+      "type": "value",
+      "value": "fit-content",
+      "for": "max-inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "fit-content",
+      "prose": "Essentially fit-content(stretch) i.e. min(max-content, max(min-content, stretch)).",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-fit-content",
+      "type": "value",
+      "value": "fit-content",
+      "for": "max-block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "contain",
+      "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
+      "type": "value",
+      "value": "contain",
+      "for": "inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "contain",
+      "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
+      "type": "value",
+      "value": "contain",
+      "for": "block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "contain",
+      "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
+      "type": "value",
+      "value": "contain",
+      "for": "min-inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "contain",
+      "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
+      "type": "value",
+      "value": "contain",
+      "for": "min-block-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "contain",
+      "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
+      "type": "value",
+      "value": "contain",
+      "for": "max-inline-size"
+    },
+    {
+      "msg": "Dangling value",
+      "name": "contain",
+      "prose": "If the box has a preferred aspect ratio, applies contain-fit sizing, attempting to fit into the box’s constraints while maintaining its preferred aspect ratio insofar as possible. See § 6.2 Contain-fit Sizing: stretching while maintaining an aspect ratio. If the box has no preferred aspect ratio, applies stretch-fit sizing.",
+      "href": "https://drafts.csswg.org/css-sizing-4/#valdef-width-contain",
+      "type": "value",
+      "value": "contain",
+      "for": "max-block-size"
+    }
+  ]
 }

package/css-values-5.json

@@ -40,6 +40,42 @@
   "atrules": [],
   "selectors": [],
   "values": [
+    {
+      "name": "<syntax>",
+      "href": "https://drafts.csswg.org/css-values-5/#typedef-syntax",
+      "type": "type",
+      "value": "'*' | <syntax-component> [ <syntax-combinator> <syntax-component> ]+"
+    },
+    {
+      "name": "<syntax-component>",
+      "href": "https://drafts.csswg.org/css-values-5/#typedef-syntax-component",
+      "type": "type",
+      "value": "<syntax-single-component> <syntax-multiplier>? | '<' transform-list '>'"
+    },
+    {
+      "name": "<syntax-single-component>",
+      "href": "https://drafts.csswg.org/css-values-5/#typedef-syntax-single-component",
+      "type": "type",
+      "value": "'<' <syntax-type-name> '>' | <ident>"
+    },
+    {
+      "name": "<syntax-type-name>",
+      "href": "https://drafts.csswg.org/css-values-5/#typedef-syntax-type-name",
+      "type": "type",
+      "value": "angle | color | custom-ident | image | integer | length | length-percentage | number | percentage | resolution | string | time | url | transform-function"
+    },
+    {
+      "name": "<syntax-combinator>",
+      "href": "https://drafts.csswg.org/css-values-5/#typedef-syntax-combinator",
+      "type": "type",
+      "value": "'|'"
+    },
+    {
+      "name": "<syntax-multiplier>",
+      "href": "https://drafts.csswg.org/css-values-5/#typedef-syntax-multiplier",
+      "type": "type",
+      "value": "[ '#' | '+' ]"
+    },
     {
       "name": "<request-url-modifier>",
       "prose": "<request-url-modifier>s are <url-modifier>s that affect the <url>’s resource request by applying associated URL request modifier steps. See CSS Values 4 § 4.5.4 URL Processing Model.",
@@ -282,7 +318,7 @@
     },
     {
       "name": "progress()",
-      "prose": "The progress() functional notation returns a <number> value representing the position of one calculation (the progress value) between two other calculations (the progress start value and progress end value). The argument calculations can resolve to any <number>, <dimension>, or <percentage>, but must have a consistent type or else the function is invalid. The result will be a <number>, made consistent with the consistent type of the arguments.",
+      "prose": "The progress() functional notation returns a <number> value representing the position of one calculation (the progress value) between two other calculations (the progress start value and progress end value). progress() is a math function.",
       "href": "https://drafts.csswg.org/css-values-5/#funcdef-progress",
       "type": "function"
     },

package/css-view-transitions-2.json

@@ -50,28 +50,28 @@
       "values": [
         {
           "name": "normal",
-          "prose": "The used value is the element’s nearest containing group name.",
+          "prose": "containingGroupName.",
           "href": "https://drafts.csswg.org/css-view-transitions-2/#valdef-view-transition-group-normal",
           "type": "value",
           "value": "normal"
         },
-        {
-          "name": "nearest",
-          "prose": "The used value is the view-transition-name computed value of the nearest ancestor whose view-transition-name computed value is not none.",
-          "href": "https://drafts.csswg.org/css-view-transitions-2/#valdef-view-transition-group-nearest",
-          "type": "value",
-          "value": "nearest"
-        },
         {
           "name": "contain",
-          "prose": "The used value is the element’s nearest containing group name.",
+          "prose": "containingGroupName.",
           "href": "https://drafts.csswg.org/css-view-transitions-2/#valdef-view-transition-group-contain",
           "type": "value",
           "value": "contain"
         },
+        {
+          "name": "nearest",
+          "prose": "The document-scoped view transition name of the element’s nearest flat tree ancestor which participates in the transition.",
+          "href": "https://drafts.csswg.org/css-view-transitions-2/#valdef-view-transition-group-nearest",
+          "type": "value",
+          "value": "nearest"
+        },
         {
           "name": "<custom-ident>",
-          "prose": "The used value is the given <custom-ident> if the element has an ancestor whose view-transition-name computed value is that <custom-ident>, otherwise the element’s nearest containing group name",
+          "prose": "group if the element has a flat tree ancestor whose document-scoped view transition name is group and participates in transition; Otherwise containingGroupName.",
           "href": "https://drafts.csswg.org/css-view-transitions-2/#valdef-view-transition-group-custom-ident",
           "type": "value",
           "value": "<custom-ident>"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@webref/css",
   "description": "CSS definitions of the web platform",
-  "version": "6.16.0",
+  "version": "6.17.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/w3c/webref.git"

package/selectors.json

@@ -268,12 +268,12 @@
     },
     {
       "name": ":user-invalid",
-      "prose": "The :user-invalid and the :user-valid pseudo-classes represent an element with incorrect or correct input, respectively, but only after the user has significantly interacted with it.",
+      "prose": "The :user-invalid and the :user-valid pseudo-classes represent an element with incorrect or correct input, respectively, but only after the user has significantly interacted with it. Their purpose is to help the user identify mistakes in their input.",
       "href": "https://drafts.csswg.org/selectors-4/#user-invalid-pseudo"
     },
     {
       "name": ":user-valid",
-      "prose": "The :user-invalid and the :user-valid pseudo-classes represent an element with incorrect or correct input, respectively, but only after the user has significantly interacted with it.",
+      "prose": "The :user-invalid and the :user-valid pseudo-classes represent an element with incorrect or correct input, respectively, but only after the user has significantly interacted with it. Their purpose is to help the user identify mistakes in their input.",
       "href": "https://drafts.csswg.org/selectors-4/#user-valid-pseudo"
     },
     {

package/css-highlight-api.json

@@ -1,23 +0,0 @@
-{
-  "spec": {
-    "title": "CSS Custom Highlight API Module Level 1",
-    "url": "https://drafts.csswg.org/css-highlight-api-1/"
-  },
-  "properties": [],
-  "atrules": [],
-  "selectors": [
-    {
-      "name": "::highlight()",
-      "value": "::highlight(<custom-highlight-name>)",
-      "href": "https://drafts.csswg.org/css-highlight-api-1/#selectordef-highlight-custom-highlight-name"
-    }
-  ],
-  "values": [
-    {
-      "name": "<custom-highlight-name>",
-      "prose": "The ::highlight(<custom-highlight-name>) pseudo-element (also known as the custom highlight pseudo-element) represents the portion of a document that is being contained or partially contained in all the ranges of the registered custom highlight with the custom highlight name <custom-highlight-name>, if any. <custom-highlight-name> must be a valid CSS <ident-token>.",
-      "href": "https://drafts.csswg.org/css-highlight-api-1/#typedef-custom-highlight-name",
-      "type": "type"
-    }
-  ]
-}