diff --git a/Source/WebCore/css/CSSProperties.json b/Source/WebCore/css/CSSProperties.json
index 66aab45c6ae9..d6fa99b2ff98 100644
--- a/Source/WebCore/css/CSSProperties.json
+++ b/Source/WebCore/css/CSSProperties.json
@@ -229,9 +229,11 @@
         "Indicates that a CSSValuePool is required by the custom parser. Either 'custom-parser'",
         "or 'parser-function' must also be specified for this to be valid.",
         "",
-        "* partial-keyword-property:",
-        "Indicates that in addition to single keyword values, this property can also take other",
-        "values in a valid parse. ",
+        "* parser-grammar:",
+        "An array of terms that define the grammar for the property.",
+        "",
+        "* parser-grammar-comment:",
+        "A comment specific to the `parser-grammar` value.",
         "",
         "2. Lesser known capabilities of this file format",
         "",
@@ -285,8 +287,7 @@
                 "auto-functions": true,
                 "color-property": true,
                 "settings-flag": "accentColorEnabled",
-                "parser-function": "consumeAutoOrColor",
-                "parser-requires-context": true
+                "parser-grammar": ["auto", "<color>"]
             },
             "status": {
                 "status": "experimental"
@@ -302,8 +303,7 @@
                 "visited-link-color-support": true,
                 "color-property": true,
                 "custom": "All",
-                "parser-function": "consumeAutoOrColor",
-                "parser-requires-context": true
+                "parser-grammar": ["auto", "<color>"]
             },
             "specification": {
                 "category": "css-ui",
@@ -318,9 +318,7 @@
                 "custom": "Value",
                 "high-priority": true,
                 "fast-path-inherited": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true,
-                "parser-requires-quirks-mode": true
+                "parser-grammar": ["<color accept-quirky-colors-in-quirks-mode>"]
             },
             "status": {
                 "comment": "All the values from CSS Color Level 3 are supported, as well as the 8- and 4-digit forms of hex color, and the color() function."
@@ -431,9 +429,8 @@
             "codegen-properties": {
                 "custom": "All",
                 "high-priority": true,
-                "custom-parser": true,
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Allow"]
+                "parser-grammar": ["<absolute-size>", "<relative-size>", "<length-percentage [0,inf] unitless-allowed>", "<-webkit-absolute-size>", "<-webkit-relative-size>"],
+                "parser-exported": true
             },
             "specification": {
                 "category": "css-fonts",
@@ -446,7 +443,7 @@
                 "custom": "Value",
                 "font-property": true,
                 "high-priority": true,
-                "custom-parser": true
+                "parser-grammar": ["none", "<number [0,inf]>"]
             },
             "specification": {
                 "category": "css-fonts",
@@ -589,7 +586,7 @@
                 "converter": "FontPalette",
                 "font-property": true,
                 "high-priority": true,
-                "custom-parser": true
+                "parser-grammar": ["normal", "light", "dark", "<palette-identifier>"]
             },
             "specification": {
                 "category": "css-fonts",
@@ -634,7 +631,8 @@
             "codegen-properties": {
                 "name-for-methods": "VariantPosition",
                 "font-property": true,
-                "high-priority": true
+                "high-priority": true,
+                "parser-exported": true
             },
             "status": {
                 "status": "in development",
@@ -659,7 +657,8 @@
             "codegen-properties": {
                 "name-for-methods": "VariantCaps",
                 "font-property": true,
-                "high-priority": true
+                "high-priority": true,
+                "parser-exported": true
             },
             "specification": {
                 "category": "css-fonts",
@@ -846,7 +845,7 @@
                 "font-property": true,
                 "high-priority": true,
                 "name-for-methods": "SpecifiedLocale",
-                "parser-function": "consumeAutoOrString"
+                "parser-grammar": ["auto", "<string>"]
             },
             "status": "non-standard"
         },
@@ -897,7 +896,7 @@
                 "high-priority": true,
                 "enable-if": "ENABLE_TEXT_AUTOSIZING",
                 "settings-flag": "textAutosizingEnabled",
-                "parser-function": "consumeTextSizeAdjust"
+                "parser-grammar": ["auto", "none", "<percentage [0,inf]>"]
             },
             "status": "experimental",
             "specification": {
@@ -983,7 +982,7 @@
             "codegen-properties": {
                 "custom": "All",
                 "high-priority": true,
-                "custom-parser": true
+                "parser-grammar": ["normal", "reset", "document", "<percentage [0,inf]>", "<number [0,inf]>"]
             },
             "status": "non-standard",
             "specification": {
@@ -1383,9 +1382,7 @@
             "codegen-properties": {
                 "visited-link-color-support": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true,
-                "parser-requires-quirks-mode": true
+                "parser-grammar": ["<color accept-quirky-colors-in-quirks-mode>"]
             },
             "specification": {
                 "category": "css-backgrounds",
@@ -1491,7 +1488,7 @@
             "codegen-properties": {
                 "custom": "Value",
                 "svg": true,
-                "custom-parser": true
+                "parser-grammar": ["baseline", "sub", "super", "<length-percentage svg>"]
             },
             "specification": {
                 "category": "svg",
@@ -1508,8 +1505,7 @@
                     "name": "size",
                     "resolver": "block"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true
+                "parser-grammar": ["<width-or-height>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -1597,8 +1593,7 @@
                     "name": "border-color",
                     "resolver": "block-end"
                 },
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -1643,9 +1638,7 @@
                     "name": "border-width",
                     "resolver": "block-end"
                 },
-                "parser-function": "consumeLineWidth",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<line-width>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -1680,8 +1673,7 @@
                     "name": "border-color",
                     "resolver": "block-start"
                 },
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -1726,9 +1718,7 @@
                     "name": "border-width",
                     "resolver": "block-start"
                 },
-                "parser-function": "consumeLineWidth",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<line-width>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -1977,8 +1967,7 @@
         "border-image-source": {
             "codegen-properties": {
                 "converter": "StyleImage<CSSPropertyBorderImageSource>",
-                "parser-function": "consumeImageOrNone",
-                "parser-requires-context": true
+                "parser-grammar": ["none", "<image>"]
             },
             "specification": {
                 "category": "css-backgrounds",
@@ -2054,8 +2043,7 @@
                     "name": "border-color",
                     "resolver": "inline-end"
                 },
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -2100,9 +2088,7 @@
                     "name": "border-width",
                     "resolver": "inline-end"
                 },
-                "parser-function": "consumeLineWidth",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<line-width>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -2137,8 +2123,7 @@
                     "name": "border-color",
                     "resolver": "inline-start"
                 },
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -2183,9 +2168,7 @@
                     "name": "border-width",
                     "resolver": "inline-start"
                 },
-                "parser-function": "consumeLineWidth",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<line-width>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -2933,8 +2916,7 @@
             "codegen-properties": {
                 "initial": "initialZeroLength",
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-additional-parameters": ["SVGAttributeMode", "ValueRange::All", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage svg>"]
             },
             "specification": {
                 "category": "svg",
@@ -2945,8 +2927,7 @@
             "codegen-properties": {
                 "initial": "initialZeroLength",
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-additional-parameters": ["SVGAttributeMode", "ValueRange::All", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage svg>"]
             },
             "specification": {
                 "category": "svg",
@@ -3018,7 +2999,7 @@
             "codegen-properties": {
                 "converter": "Opacity",
                 "svg": true,
-                "parser-function": "consumeOpacity"
+                "parser-grammar": "<alpha-value>"
             },
             "specification": {
                 "category": "svg",
@@ -3065,8 +3046,7 @@
             "codegen-properties": {
                 "svg": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification": {
                 "category": "svg",
@@ -3077,11 +3057,11 @@
             "codegen-properties": {
                 "converter": "Opacity",
                 "svg": true,
-                "parser-function": "consumeOpacity"
+                "parser-grammar": "<alpha-value>"
             },
             "specification": {
-                "category": "svg",
-                "url": "https://www.w3.org/TR/SVG/filters.html#FloodOpacityProperty"
+                "category": "css-filters",
+                "url": "https://www.w3.org/TR/filter-effects/#FloodOpacityProperty"
             }
         },
         "glyph-orientation-horizontal": {
@@ -3089,8 +3069,7 @@
             "codegen-properties": {
                 "converter": "GlyphOrientation",
                 "svg": true,
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<angle unitless-allowed unitless-zero-allowed>"]
             },
             "specification": {
                 "category": "svg",
@@ -3102,8 +3081,7 @@
             "codegen-properties": {
                 "converter": "GlyphOrientationOrAuto",
                 "svg": true,
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<angle unitless-allowed unitless-zero-allowed>"]
             },
             "specification": {
                 "category": "svg",
@@ -3129,9 +3107,7 @@
                     "name": "size",
                     "resolver": "vertical"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Allow"]
+                "parser-grammar": ["<width-or-height-unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -3215,8 +3191,7 @@
                     "name": "size",
                     "resolver": "inline"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true
+                "parser-grammar": ["<width-or-height>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3271,9 +3246,7 @@
                     "name": "inset",
                     "resolver": "block-end"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<inset-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3287,9 +3260,7 @@
                     "name": "inset",
                     "resolver": "block-start"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<inset-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3316,9 +3287,7 @@
                     "name": "inset",
                     "resolver": "inline-end"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<inset-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3332,9 +3301,7 @@
                     "name": "inset",
                     "resolver": "inline-start"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<inset-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3346,8 +3313,7 @@
             "codegen-properties": {
                 "converter": "SVGLengthValue",
                 "svg": true,
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "normal", "<length unitless-allowed>"]
             },
             "specification": {
                 "category": "svg",
@@ -3379,8 +3345,7 @@
                 "high-priority": true,
                 "sink-priority": true,
                 "converter": "Spacing",
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["normal", "<length unitless-allowed>"]
             },
             "specification": {
                 "category": "css-text",
@@ -3391,8 +3356,7 @@
             "codegen-properties": {
                 "svg": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             }
         },
         "line-height": {
@@ -3401,20 +3365,20 @@
                 {
                     "custom": "All",
                     "enable-if": "ENABLE_TEXT_AUTOSIZING",
-                    "custom-parser": true,
-                    "parser-requires-context-mode": true
+                    "parser-grammar": ["normal", "<number [0,inf]>", "<length-percentage [0,inf]>"],
+                    "parser-exported": true
                 },
                 {
                     "getter": "specifiedLineHeight",
                     "conditional-converter": "LineHeight",
                     "enable-if": "!ENABLE_TEXT_AUTOSIZING",
-                    "custom-parser": true,
-                    "parser-requires-context-mode": true
+                    "parser-grammar": ["normal", "<number [0,inf]>", "<length-percentage [0,inf]>"],
+                    "parser-exported": true
                 }
             ],
             "specification": {
-                "category": "css-22",
-                "url": "https://www.w3.org/TR/CSS22/visudet.html#propdef-line-height"
+                "category": "css-inline",
+                "url": "https://www.w3.org/TR/css-inline-3/#line-height-property"
             }
         },
         "list-style": {
@@ -3436,9 +3400,7 @@
             "inherited": true,
             "codegen-properties": {
                 "converter": "StyleImage<CSSPropertyListStyleImage>",
-                "parser-function": "consumeImageOrNone",
-                "parser-requires-context": true
-
+                "parser-grammar": ["none", "<image>"]
             },
             "specification": {
                 "category": "css-lists",
@@ -3557,9 +3519,7 @@
             ],
             "codegen-properties": {
                 "custom": "All",
-                "custom-parser": true,
-                "parser-requires-context": true,
-                "partial-keyword-property": true
+                "parser-grammar": ["<<values>>", "<string>"]
             },
             "specification": {
                 "category": "css-lists",
@@ -3604,9 +3564,7 @@
                     "name": "margin",
                     "resolver": "block-end"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<margin-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3623,9 +3581,7 @@
                     "name": "margin",
                     "resolver": "block-start"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<margin-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3672,9 +3628,7 @@
                     "name": "margin",
                     "resolver": "inline-end"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<margin-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3691,9 +3645,7 @@
                     "name": "margin",
                     "resolver": "inline-start"
                 },
-                "parser-function": "consumeMarginOrOffset",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<margin-logical-start-end>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -3772,7 +3724,7 @@
                 "name-for-methods": "MarkerEndResource",
                 "converter": "SVGURIReference",
                 "svg": true,
-                "parser-function": "consumeNoneOrURL"
+                "parser-grammar": ["none", "<marker-ref>"]
             },
             "specification": {
                 "category": "svg",
@@ -3785,7 +3737,7 @@
                 "name-for-methods": "MarkerMidResource",
                 "converter": "SVGURIReference",
                 "svg": true,
-                "parser-function": "consumeNoneOrURL"
+                "parser-grammar": ["none", "<marker-ref>"]
             },
             "specification": {
                 "category": "svg",
@@ -3798,7 +3750,7 @@
                 "name-for-methods": "MarkerStartResource",
                 "converter": "SVGURIReference",
                 "svg": true,
-                "parser-function": "consumeNoneOrURL"
+                "parser-grammar": ["none", "<marker-ref>"]
             },
             "specification": {
                 "category": "svg",
@@ -4027,8 +3979,7 @@
                     "name": "max-size",
                     "resolver": "block"
                 },
-                "parser-function": "consumeMaxWidthOrHeight",
-                "parser-requires-context": true
+                "parser-grammar": ["<max-width-or-height>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4043,9 +3994,7 @@
                     "name": "max-size",
                     "resolver": "vertical"
                 },
-                "parser-function": "consumeMaxWidthOrHeight",
-                "parser-requires-context": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Allow"]
+                "parser-grammar": ["<max-width-or-height-unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4062,8 +4011,7 @@
                     "name": "max-size",
                     "resolver": "inline"
                 },
-                "parser-function": "consumeMaxWidthOrHeight",
-                "parser-requires-context": true
+                "parser-grammar": ["<max-width-or-height>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4078,9 +4026,7 @@
                     "name": "max-size",
                     "resolver": "horizontal"
                 },
-                "parser-function": "consumeMaxWidthOrHeight",
-                "parser-requires-context": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Allow"]
+                "parser-grammar": ["<max-width-or-height-unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4097,8 +4043,7 @@
                     "name": "min-size",
                     "resolver": "block"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true
+                "parser-grammar": ["<width-or-height>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4113,9 +4058,7 @@
                     "name": "min-size",
                     "resolver": "vertical"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Allow"]
+                "parser-grammar": ["<width-or-height-unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4132,8 +4075,7 @@
                     "name": "min-size",
                     "resolver": "inline"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true
+                "parser-grammar": ["<width-or-height>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4148,9 +4090,7 @@
                     "name": "min-size",
                     "resolver": "horizontal"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Allow"]
+                "parser-grammar": ["<width-or-height-unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4173,9 +4113,7 @@
         "object-position": {
             "codegen-properties": {
                 "converter": "Position",
-                "parser-function": "consumePosition",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid", "PositionSyntax::Position"]
+                "parser-grammar": ["<position>"]
             },
             "specification": {
                 "category": "css-images",
@@ -4199,9 +4137,7 @@
             "codegen-properties": {
                 "converter": "Length",
                 "settings-flag": "cssMotionPathEnabled",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage>"]
             },
             "specification": {
                 "category": "css-motion-path",
@@ -4212,9 +4148,7 @@
             "codegen-properties": {
                 "converter": "PositionOrAuto",
                 "settings-flag": "cssMotionPathEnabled",
-                "parser-function": "consumeAutoOrPosition",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid", "PositionSyntax::Position"]
+                "parser-grammar": ["auto", "<position>"]
             },
             "specification": {
                 "category": "css-motion-path",
@@ -4225,9 +4159,7 @@
             "codegen-properties": {
                 "converter": "PositionOrAuto",
                 "settings-flag": "cssMotionPathEnabled",
-                "parser-function": "consumeAutoOrPosition",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid", "PositionSyntax::Position"]
+                "parser-grammar": ["auto", "<position>"]
             },
             "specification": {
                 "category": "css-motion-path",
@@ -4269,21 +4201,21 @@
                 "aliases": [
                     "-webkit-opacity"
                 ],
-                "parser-function": "consumeOpacity"
+                "parser-grammar": ["<alpha-value>"]
             },
             "status": {
                 "comment": "Honor -webkit-opacity as a synonym for opacity. This was the only syntax that worked in Safari 1.1, and may be in use on some websites and widgets."
             },
             "specification": {
                 "category": "css-color",
-                "url": "https://www.w3.org/TR/css3-color/#opacity"
+                "url": "https://www.w3.org/TR/css-color-4/#propdef-opacity"
             }
         },
         "orphans": {
             "inherited": true,
             "codegen-properties": {
                 "auto-functions": true,
-                "parser-function": "consumePositiveInteger"
+                "parser-grammar": ["<integer [1,inf]>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4309,8 +4241,7 @@
                 "initial": "currentColor",
                 "visited-link-color-support": true,
                 "color-property": true,
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["-webkit-focus-ring-color", "<color>"]
             },
             "specification": {
                 "category": "css-ui",
@@ -4320,9 +4251,7 @@
         "outline-offset": {
             "codegen-properties": {
                 "converter": "ComputedLength<float>",
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-ui",
@@ -4353,9 +4282,7 @@
         "outline-width": {
             "codegen-properties": {
                 "converter": "LineWidth<float>",
-                "parser-function": "consumeLineWidth",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<line-width>"]
             },
             "specification": {
                 "category": "css-ui",
@@ -4480,7 +4407,8 @@
                 "logical-property-group": {
                     "name": "overscroll-behavior",
                     "resolver": "horizontal"
-                }
+                },
+                "parser-exported": true
             },
             "status": {
                 "status": "in development"
@@ -4500,7 +4428,8 @@
                 "logical-property-group": {
                     "name": "overscroll-behavior",
                     "resolver": "vertical"
-                }
+                },
+                "parser-exported": true
             },
             "status": {
                 "status": "in development"
@@ -4601,9 +4530,7 @@
                     "name": "padding",
                     "resolver": "block-end"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4620,9 +4547,7 @@
                     "name": "padding",
                     "resolver": "block-start"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4637,9 +4562,7 @@
                     "name": "padding",
                     "resolver": "bottom"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Allow"]
+                "parser-grammar": ["<length-percentage [0,inf] unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4669,9 +4592,7 @@
                     "name": "padding",
                     "resolver": "inline-end"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4688,9 +4609,7 @@
                     "name": "padding",
                     "resolver": "inline-start"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-logical-props",
@@ -4705,9 +4624,7 @@
                     "name": "padding",
                     "resolver": "left"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Allow"]
+                "parser-grammar": ["<length-percentage [0,inf] unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4722,9 +4639,7 @@
                     "name": "padding",
                     "resolver": "right"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Allow"]
+                "parser-grammar": ["<length-percentage [0,inf] unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4739,9 +4654,7 @@
                     "name": "padding",
                     "resolver": "top"
                 },
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Allow"]
+                "parser-grammar": ["<length-percentage [0,inf] unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -4751,7 +4664,7 @@
         "page": {
             "codegen-properties": {
                 "skip-builder": true,
-                "custom-parser": true
+                "parser-grammar": ["auto", "<custom-ident>"]
             },
             "specification": {
                 "category": "css-page",
@@ -4867,9 +4780,7 @@
             "codegen-properties": {
                 "initial": "initialZeroLength",
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "svg",
@@ -4924,8 +4835,7 @@
             "codegen-properties": {
                 "initial": "initialRadius",
                 "converter": "LengthOrAuto",
-                "parser-function": "consumeRxOrRy",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "svg",
@@ -4936,8 +4846,7 @@
             "codegen-properties": {
                 "initial": "initialRadius",
                 "converter": "LengthOrAuto",
-                "parser-function": "consumeRxOrRy",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "svg",
@@ -5008,8 +4917,7 @@
             "codegen-properties": {
                 "svg": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification": {
                 "category": "svg",
@@ -5020,7 +4928,7 @@
             "codegen-properties": {
                 "converter": "Opacity",
                 "svg": true,
-                "parser-function": "consumeOpacity"
+                "parser-grammar": ["<alpha-value>"]
             },
             "specification": {
                 "category": "svg",
@@ -5060,8 +4968,7 @@
                 "initial": "initialZeroLength",
                 "name-for-methods": "StrokeDashOffset",
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-additional-parameters": ["SVGAttributeMode", "ValueRange::All", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage svg>"]
             },
             "specification": {
                 "category": "svg",
@@ -5109,8 +5016,7 @@
             "codegen-properties": {
                 "name-for-methods": "StrokeMiterLimit",
                 "converter": "Number<float>",
-                "parser-function": "consumeNumber",
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative"]
+                "parser-grammar": ["<number [0,inf]>"]
             },
             "status": "supported",
             "specification": {
@@ -5125,7 +5031,7 @@
             "codegen-properties": {
                 "converter": "Opacity",
                 "svg": true,
-                "parser-function": "consumeOpacity"
+                "parser-grammar": ["<alpha-value>"]
             },
             "specification": {
                 "category": "svg",
@@ -5138,8 +5044,7 @@
                 "custom": "Value",
                 "visited-link-color-support": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "status": "supported",
             "specification": {
@@ -5153,8 +5058,7 @@
                 "custom": "Value",
                 "initial": "initialOneLength",
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-additional-parameters": ["SVGAttributeMode", "ValueRange::All", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage svg>"]
             },
             "status": "supported",
             "specification": {
@@ -5201,8 +5105,7 @@
             "inherited": true,
             "codegen-properties": {
                 "converter": "TabSize",
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<number [0,inf]>", "<length [0,inf]>"]
             },
             "specification": {
                 "category": "css-text",
@@ -5757,8 +5660,21 @@
         "vertical-align": {
             "codegen-properties": {
                 "custom": "Inherit|Value",
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": [
+                    "baseline",
+                    "sub",
+                    "super",
+                    "top",
+                    "text-top",
+                    "middle",
+                    "bottom",
+                    "text-bottom",
+                    {
+                        "value": "-webkit-baseline-middle",
+                        "status": "non-standard"
+                    },
+                    "<length-percentage unitless-allowed>"
+                 ]
             },
             "specification": {
                 "category": "css-22",
@@ -5796,7 +5712,7 @@
             "inherited": true,
             "codegen-properties": {
                 "auto-functions": true,
-                "parser-function": "consumePositiveInteger"
+                "parser-grammar": ["<integer [1,inf]>"]
             },
             "specification": {
                 "category": "css-22",
@@ -5811,9 +5727,7 @@
                     "name": "size",
                     "resolver": "horizontal"
                 },
-                "parser-function": "consumeWidthOrHeight",
-                "parser-requires-context": true,
-                "parser-requires-additional-parameters": ["UnitlessQuirk::Allow"]
+                "parser-grammar": ["<width-or-height-unitless-allowed>"]
             },
             "specification": {
                 "category": "css-22",
@@ -5853,8 +5767,8 @@
             "inherited": true,
             "codegen-properties": {
                 "conditional-converter": "WordSpacing",
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["normal", "<length-percentage unitless-allowed>"],
+                "parser-grammar-comment": "The current specification has a <length>, not a <length-percentage>"
             },
             "specification": {
                 "category": "css-22",
@@ -5865,8 +5779,7 @@
             "codegen-properties": {
                 "initial": "initialZeroLength",
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-additional-parameters": ["SVGAttributeMode", "ValueRange::All", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage svg>"]
             },
             "specification": {
                 "category": "svg",
@@ -5877,8 +5790,7 @@
             "codegen-properties": {
                 "initial": "initialZeroLength",
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-additional-parameters": ["SVGAttributeMode", "ValueRange::All", "UnitlessQuirk::Forbid"]
+                "parser-grammar": ["<length-percentage svg>"]
             },
             "specification": {
                 "category": "svg",
@@ -5889,7 +5801,7 @@
             "codegen-properties": {
                 "auto-functions": true,
                 "name-for-methods": "SpecifiedZIndex",
-                "custom-parser": true
+                "parser-grammar": ["auto", "<integer>"]
             },
             "specification": {
                 "category": "css-22",
@@ -6195,9 +6107,7 @@
             "codegen-properties": {
                 "name-for-methods": "HorizontalBorderSpacing",
                 "converter": "ComputedLength<float>",
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative"]
+                "parser-grammar": ["<length [0,inf]>"]
             },
             "status": "non-standard"
         },
@@ -6235,9 +6145,7 @@
             "codegen-properties": {
                 "name-for-methods": "VerticalBorderSpacing",
                 "converter": "ComputedLength<float>",
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative"]
+                "parser-grammar": ["<length [0,inf]>"]
             },
             "status": "non-standard"
         },
@@ -6269,8 +6177,7 @@
         },
         "-webkit-box-flex": {
             "codegen-properties": {
-                "parser-function": "consumeNumber",
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<number>"]
             },
             "status": "obsolete",
             "specification":  {
@@ -6280,7 +6187,7 @@
         },
         "-webkit-box-flex-group": {
             "codegen-properties": {
-                "parser-function": "consumeIntegerZeroAndGreater"
+                "parser-grammar": ["<integer [0,inf]>"]
             },
             "status": "obsolete",
             "specification":  {
@@ -6301,7 +6208,7 @@
         },
         "-webkit-box-ordinal-group": {
             "codegen-properties": {
-                "parser-function": "consumePositiveInteger"
+                "parser-grammar": ["<integer [1,inf]>"]
             },
             "status": "obsolete",
             "specification":  {
@@ -6418,7 +6325,8 @@
                     "-webkit-column-count"
                 ],
                 "auto-functions": true,
-                "custom-parser": true
+                "parser-grammar": ["auto", "<integer [1,inf]>"],
+                "parser-exported": true
             },
             "specification":  {
                 "category": "css-multicol",
@@ -6447,10 +6355,10 @@
                     "-webkit-column-gap"
                 ],
                 "converter": "GapLength",
-                "parser-function": "consumeGapLength",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<gap-gutter>"],
+                "parser-exported": true
             },
-            "specification":  {
+            "specification": {
                 "category": "css-align",
                 "url": "https://drafts.csswg.org/css-align/#column-row-gap"
             }
@@ -6461,8 +6369,8 @@
                     "grid-row-gap"
                 ],
                 "converter": "GapLength",
-                "parser-function": "consumeGapLength",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<gap-gutter>"],
+                "parser-exported": true
             },
             "specification": {
                 "category": "css-align",
@@ -6520,8 +6428,7 @@
                 "initial": "currentColor",
                 "visited-link-color-support": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification":  {
                 "category": "css-multicol",
@@ -6558,8 +6465,7 @@
                     "-webkit-column-rule-width"
                 ],
                 "converter": "LineWidth<unsigned short>",
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<line-width>"]
             },
             "specification":  {
                 "category": "css-multicol",
@@ -6588,7 +6494,8 @@
                 ],
                 "converter": "ComputedLength<float>",
                 "auto-functions": true,
-                "custom-parser": true
+                "parser-grammar": ["auto", "<length [0,inf] strict>"],
+                "parser-exported": true
             },
             "specification":  {
                 "category": "css-multicol",
@@ -6789,8 +6696,7 @@
                     "-webkit-flex-basis"
                 ],
                 "converter": "LengthSizing",
-                "custom-parser": true,
-                "parser-requires-context": true
+                "parser-grammar": ["auto", "content", "<width-or-height-keyword>", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-flexbox",
@@ -6835,8 +6741,7 @@
                 "aliases": [
                     "-webkit-flex-grow"
                 ],
-                "parser-function": "consumeNumber",
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative"]
+                "parser-grammar": ["<number [0,inf]>"]
             },
             "specification": {
                 "category": "css-flexbox",
@@ -6848,8 +6753,7 @@
                 "aliases": [
                     "-webkit-flex-shrink"
                 ],
-                "parser-function": "consumeNumber",
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative"]
+                "parser-grammar": ["<number [0,inf]>"]
             },
             "specification": {
                 "category": "css-flexbox",
@@ -6913,9 +6817,7 @@
             "codegen-properties": {
                 "skip-builder": true,
                 "internal-only": true,
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All, UnitlessQuirk::Allow"]
+                "parser-grammar": ["<length unitless-allowed>"]
             },
             "status": "non-standard"
         },
@@ -7172,7 +7074,7 @@
             "codegen-properties": {
                 "name-for-methods": "HyphenationString",
                 "converter": "StringOrAutoAtom",
-                "parser-function": "consumeAutoOrString"
+                "parser-grammar": ["auto", "<string>"]
             },
             "status": {
                 "status": "experimental"
@@ -7187,8 +7089,7 @@
             "codegen-properties": {
                 "name-for-methods": "HyphenationLimitAfter",
                 "converter": "NumberOrAuto<short>",
-                "parser-function": "consumeHyphenateLimit",
-                "parser-requires-additional-parameters": ["CSSValueAuto"]
+                "parser-grammar": ["auto", "<number [0,inf]>"]
             },
             "status": "non-standard"
         },
@@ -7197,8 +7098,7 @@
             "codegen-properties": {
                 "name-for-methods": "HyphenationLimitBefore",
                 "converter": "NumberOrAuto<short>",
-                "parser-function": "consumeHyphenateLimit",
-                "parser-requires-additional-parameters": ["CSSValueAuto"]
+                "parser-grammar": ["auto", "<number [0,inf]>"]
             },
             "status": "non-standard"
         },
@@ -7207,8 +7107,7 @@
             "codegen-properties": {
                 "name-for-methods": "HyphenationLimitLines",
                 "converter": "WebkitHyphenateLimitLines",
-                "parser-function": "consumeHyphenateLimit",
-                "parser-requires-additional-parameters": ["CSSValueNoLimit"]
+                "parser-grammar": ["no-limit", "<number [0,inf]>"]
             },
             "status": {
                 "status": "experimental"
@@ -7312,7 +7211,7 @@
         },
         "-webkit-line-clamp": {
             "codegen-properties": {
-                "custom-parser": true
+                "parser-grammar": ["<percentage [0,inf]>", "<integer [1,inf]>"]
             },
             "status": "non-standard"
         },
@@ -7320,7 +7219,7 @@
             "inherited": true,
             "codegen-properties": {
                 "converter": "StringOrNoneAtom",
-                "custom-parser": true
+                "parser-grammar": ["none", "<custom-ident>"]
             },
             "status": {
                 "status": "experimental"
@@ -7386,8 +7285,7 @@
             "codegen-properties": {
                 "conditional-converter": "MarqueeIncrement",
                 "internal-only": true,
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<length-percentage unitless-allowed>"]
             },
             "status": "non-standard"
         },
@@ -7396,7 +7294,7 @@
                 "name-for-methods": "MarqueeLoopCount",
                 "converter": "MarqueeRepetition",
                 "internal-only": true,
-                "custom-parser": true
+                "parser-grammar": ["<number [0,inf]>"]
             },
             "status": "non-standard"
         },
@@ -7404,8 +7302,7 @@
             "codegen-properties": {
                 "converter": "MarqueeSpeed",
                 "internal-only": true,
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<time [0,inf] unitless-allowed>"]
             },
             "status": "non-standard"
         },
@@ -7489,8 +7386,7 @@
         "-webkit-mask-box-image-source": {
             "codegen-properties": {
                 "converter": "StyleImage<CSSPropertyWebkitMaskBoxImageSource>",
-                "parser-function": "consumeImageOrNone",
-                "parser-requires-context": true
+                "parser-grammar": ["none", "<image>"]
             },
             "status": "non-standard",
             "specification": {
@@ -7613,7 +7509,7 @@
                 "aliases": [
                     "-webkit-order"
                 ],
-                "parser-function": "consumeInteger"
+                "parser-grammar": ["<integer>"]
             },
             "specification": {
                 "category": "css-flexbox",
@@ -7855,8 +7751,7 @@
                 "initial": "currentColor",
                 "visited-link-color-support": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "specification": {
                 "category": "css-text-decor",
@@ -7913,8 +7808,8 @@
             "inherited": true,
             "codegen-properties": {
                 "converter": "TextUnderlineOffset",
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length>"],
+                "parser-grammar-comment": "The current specification has a <length> | <percentage>, not just <length>"
             },
             "specification": {
                 "category": "css-text-decor",
@@ -7924,8 +7819,8 @@
         "text-decoration-thickness": {
             "codegen-properties": {
                 "converter": "TextDecorationThickness",
-                "custom-parser": true,
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "from-font", "<length>"],
+                "parser-grammar-comment": "The current specification has a <length> | <percentage>, not just <length>"
             },
             "specification": {
                 "category": "css-text-decor",
@@ -7982,8 +7877,7 @@
                 "initial": "currentColor",
                 "visited-link-color-support": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "status": {
                 "status": "experimental"
@@ -8034,8 +7928,7 @@
                 "initial": "currentColor",
                 "visited-link-color-support": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "status": {
                 "status": "non-standard",
@@ -8069,8 +7962,7 @@
                 "initial": "currentColor",
                 "visited-link-color-support": true,
                 "color-property": true,
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "status": {
                 "status": "non-standard",
@@ -8081,8 +7973,7 @@
             "inherited": true,
             "codegen-properties": {
                 "converter": "TextStrokeWidth",
-                "parser-function": "consumeTextStrokeWidth",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["<line-width>"]
             },
             "status": {
                 "status": "non-standard",
@@ -8173,9 +8064,7 @@
                 ],
                 "computable": false,
                 "converter": "ComputedLength<float>",
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-transforms",
@@ -8324,9 +8213,7 @@
                     "name": "scroll-margin",
                     "resolver": "bottom"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8344,9 +8231,7 @@
                     "name": "scroll-margin",
                     "resolver": "left"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8364,9 +8249,7 @@
                     "name": "scroll-margin",
                     "resolver": "right"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8384,9 +8267,7 @@
                     "name": "scroll-margin",
                     "resolver": "top"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8400,9 +8281,7 @@
                     "name": "scroll-margin",
                     "resolver": "inline-start"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8416,9 +8295,7 @@
                     "name": "scroll-margin",
                     "resolver": "block-start"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8432,9 +8309,7 @@
                     "name": "scroll-margin",
                     "resolver": "inline-end"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8448,9 +8323,7 @@
                     "name": "scroll-margin",
                     "resolver": "block-end"
                 },
-                "parser-function": "consumeLength",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<length>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8506,8 +8379,7 @@
                     "name": "scroll-padding",
                     "resolver": "bottom"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8522,8 +8394,7 @@
                     "name": "scroll-padding",
                     "resolver": "left"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8538,8 +8409,7 @@
                     "name": "scroll-padding",
                     "resolver": "right"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8554,8 +8424,7 @@
                     "name": "scroll-padding",
                     "resolver": "top"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8569,8 +8438,7 @@
                     "name": "scroll-padding",
                     "resolver": "inline-start"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8584,8 +8452,7 @@
                     "name": "scroll-padding",
                     "resolver": "block-start"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8599,8 +8466,7 @@
                     "name": "scroll-padding",
                     "resolver": "inline-end"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8614,8 +8480,7 @@
                     "name": "scroll-padding",
                     "resolver": "block-end"
                 },
-                "parser-function": "consumeScrollPadding",
-                "parser-requires-context-mode": true
+                "parser-grammar": ["auto", "<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-scroll-snap",
@@ -8701,9 +8566,7 @@
                     "-webkit-shape-margin"
                 ],
                 "converter": "Length",
-                "parser-function": "consumeLengthOrPercent",
-                "parser-requires-context-mode": true,
-                "parser-requires-additional-parameters": ["ValueRange::NonNegative"]
+                "parser-grammar": ["<length-percentage [0,inf]>"]
             },
             "specification": {
                 "category": "css-shapes",
@@ -8716,8 +8579,7 @@
                     "-webkit-shape-image-threshold"
                 ],
                 "converter": "NumberOrAuto<float>",
-                "parser-function": "consumeNumber",
-                "parser-requires-additional-parameters": ["ValueRange::All"]
+                "parser-grammar": ["<number>"]
             },
             "specification": {
                 "category": "css-shapes",
@@ -8741,8 +8603,7 @@
             "codegen-properties": {
                 "converter": "TapHighlightColor",
                 "enable-if": "ENABLE_TOUCH_EVENTS",
-                "parser-function": "consumeColor",
-                "parser-requires-context": true
+                "parser-grammar": ["<color>"]
             },
             "status": "non-standard"
         },
@@ -9031,7 +8892,7 @@
         "css-inline": {
             "shortname": "CSS Inline Layout",
             "longname": "CSS Inline Layout Module",
-            "url": "https://www.w3.org/TR/css-inline/"
+            "url": "https://www.w3.org/TR/css-inline-3/"
         },
         "css-line-grid": {
             "shortname": "CSS Line Grid",
@@ -9163,5 +9024,146 @@
             "longname": "SVG",
             "url": "https://www.w3.org/TR/SVG11/"
         }
+    },
+    "shared-grammar-rules": {
+        "<alpha-value>": {
+            "grammar": ["<number>", "<percentage>"],
+            "specification": {
+                "category": "css-color",
+                "url": "https://www.w3.org/TR/css-color-4/#typedef-alpha-value"
+            }
+        },
+        "<marker-ref>": {
+            "grammar": ["<url>"],
+            "specification": {
+                "category": "svg",
+                "url": "https://www.w3.org/TR/SVG/painting.html#DataTypeMarkerRef"
+            }
+        },
+        "<absolute-size>": {
+            "grammar": ["xx-small", "x-small", "small", "medium", "large", "x-large", "xx-large", "xxx-large"],
+            "specification": {
+                "category": "css-fonts-4",
+                "url": "https://drafts.csswg.org/css-fonts-4/#valdef-font-size-absolute-size"
+            }
+        },
+        "<-webkit-absolute-size>": {
+            "grammar": [
+                {
+                    "value": "-webkit-xxx-large",
+                    "aliased-to": "xxx-large"
+                }
+            ],
+            "status": "non-standard"
+        },
+        "<relative-size>": {
+            "grammar": ["larger", "smaller"],
+            "specification": {
+                "category": "css-fonts-4",
+                "url": "https://drafts.csswg.org/css-fonts-4/#valdef-font-size-relative-size"
+            }
+        },
+        "<-webkit-relative-size>": {
+            "grammar": ["-webkit-ruby-text"],
+            "status": "non-standard"
+        },
+        "<gap-gutter>": {
+            "grammar": ["normal", "<length-percentage [0,inf]>"],
+            "specification": {
+                "category": "css-align",
+                "url": "https://drafts.csswg.org/css-align/#column-row-gap"
+            }
+        },
+        "<width-or-height-keyword>": {
+            "grammar": [
+                "intrinsic",
+                "min-intrinsic",
+                "min-content",
+                "webkit-min-content",
+                "max-content",
+                "webkit-max-content",
+                "webkit-fill-available",
+                "fit-content",
+                "webkit-fit-content"
+            ]
+        },
+        "<width-or-height>": {
+            "grammar": [
+                "auto",
+                "<width-or-height-keyword>",
+                "<length-percentage [0,inf]>"
+            ],
+            "exported": true,
+            "comment": "Doesn't match current specification",
+            "specification": {
+                "category": "css-sizing",
+                "url": "https://www.w3.org/TR/css-sizing-3/#preferred-size-properties"
+            }
+        },
+        "<width-or-height-unitless-allowed>": {
+            "grammar": [
+                "auto",
+                "<width-or-height-keyword>",
+                "<length-percentage [0,inf] unitless-allowed>"
+            ],
+            "comment": "Doesn't match current specification",
+            "specification": {
+                "category": "css-sizing",
+                "url": "https://www.w3.org/TR/css-sizing-3/#preferred-size-properties"
+            }
+        },
+        "<max-width-or-height>": {
+            "grammar": [
+                "none",
+                "<width-or-height-keyword>",
+                "<length-percentage [0,inf]>"
+            ],
+            "comment": "Doesn't match current specification",
+            "specification": {
+                "category": "css-sizing",
+                "url": "https://www.w3.org/TR/css-sizing-3/#max-size-properties"
+            }
+        },
+        "<max-width-or-height-unitless-allowed>": {
+            "grammar": [
+                "none",
+                "<width-or-height-keyword>",
+                "<length-percentage [0,inf] unitless-allowed>"
+            ],
+            "comment": "Doesn't match current specification",
+            "specification": {
+                "category": "css-sizing",
+                "url": "https://www.w3.org/TR/css-sizing-3/#max-size-properties"
+            }
+        },
+        "<line-width>": {
+            "grammar": ["thin", "medium", "thick", "<length [0,inf]>"],
+            "exported": true,
+            "specification": {
+                "category": "css-backgrounds",
+                "url": "https://drafts.csswg.org/css-backgrounds/#typedef-line-width"
+            }
+        },
+        "<inset-logical-start-end>": {
+            "grammar": ["auto", "<length-percentage>"],
+            "specification": {
+                "category": "css-logical-props",
+                "url": "https://www.w3.org/TR/css-logical/#inset-properties"
+            }
+        },
+        "<margin-logical-start-end>": {
+            "grammar": ["auto", "<length-percentage>"],
+            "specification": {
+                "category": "css-logical-props",
+                "url": "https://www.w3.org/TR/css-logical/#margin-properties"
+            }
+        },
+        "<palette-identifier>": {
+            "grammar": ["<dashed-ident>"],
+            "specification": {
+                "category": "css-fonts-4",
+                "url": "https://drafts.csswg.org/css-fonts-4/#typedef-font-palette-palette-identifier"
+            }
+        }
     }
 }
diff --git a/Source/WebCore/css/CSSProperty.h b/Source/WebCore/css/CSSProperty.h
index 64626f3481a0..f6e22f7c1db4 100644
--- a/Source/WebCore/css/CSSProperty.h
+++ b/Source/WebCore/css/CSSProperty.h
@@ -40,7 +40,7 @@ struct StylePropertyMetadata {
         , m_inherited(inherited)
     {
         ASSERT(propertyID != CSSPropertyInvalid);
-        ASSERT(propertyID < firstShorthandProperty);
+        ASSERT_WITH_MESSAGE(propertyID < firstShorthandProperty, "unexpected property: %d", propertyID);
     }
 
     CSSPropertyID shorthandID() const;
diff --git a/Source/WebCore/css/MediaQueryExpression.cpp b/Source/WebCore/css/MediaQueryExpression.cpp
index dce758c79e94..38f4cfdf013b 100644
--- a/Source/WebCore/css/MediaQueryExpression.cpp
+++ b/Source/WebCore/css/MediaQueryExpression.cpp
@@ -223,7 +223,7 @@ static inline bool isFeatureValidWithoutValue(const AtomString& mediaFeature, co
 
 inline RefPtr<CSSPrimitiveValue> consumeFirstValue(const String& mediaFeature, CSSParserTokenRange& range)
 {
-    if (auto value = CSSPropertyParserHelpers::consumeIntegerZeroAndGreater(range))
+    if (auto value = CSSPropertyParserHelpers::consumeNonNegativeInteger(range))
         return value;
 
     if (!featureExpectingPositiveInteger(mediaFeature) && !isAspectRatioFeature(AtomString { mediaFeature })) {
diff --git a/Source/WebCore/css/parser/CSSParserImpl.cpp b/Source/WebCore/css/parser/CSSParserImpl.cpp
index fb54c83ef429..c03b615e1c27 100644
--- a/Source/WebCore/css/parser/CSSParserImpl.cpp
+++ b/Source/WebCore/css/parser/CSSParserImpl.cpp
@@ -652,7 +652,7 @@ RefPtr<StyleRuleFontFeatureValuesBlock> CSSParserImpl::consumeFontFeatureValuesR
 
         Vector<unsigned> values;
         while (!range.atEnd()) {
-            auto value = CSSPropertyParserHelpers::consumeIntegerZeroAndGreater(range);
+            auto value = CSSPropertyParserHelpers::consumeNonNegativeInteger(range);
             if (!value)
                 return { };
             ASSERT(value->isInteger());
diff --git a/Source/WebCore/css/parser/CSSPropertyParser.cpp b/Source/WebCore/css/parser/CSSPropertyParser.cpp
index d11178580a77..42a66a12d873 100644
--- a/Source/WebCore/css/parser/CSSPropertyParser.cpp
+++ b/Source/WebCore/css/parser/CSSPropertyParser.cpp
@@ -335,7 +335,7 @@ bool CSSPropertyParser::canParseTypedCustomPropertyValue(const String& syntax)
                 return true; // For variables, we just permit everything
         }
 
-        auto primitiveVal = consumeWidthOrHeight(m_range, m_context);
+        auto primitiveVal = CSSPropertyParsing::consumeWidthOrHeight(m_range, m_context);
         if (primitiveVal && primitiveVal->isPrimitiveValue() && m_range.atEnd())
             return true;
         return false;
@@ -348,7 +348,7 @@ void CSSPropertyParser::collectParsedCustomPropertyValueDependencies(const Strin
 {
     if (syntax != "*"_s) {
         m_range.consumeWhitespace();
-        auto primitiveVal = consumeWidthOrHeight(m_range, m_context);
+        auto primitiveVal = CSSPropertyParsing::consumeWidthOrHeight(m_range, m_context);
         if (!m_range.atEnd())
             return;
         if (primitiveVal && primitiveVal->isPrimitiveValue()) {
@@ -363,7 +363,7 @@ RefPtr<CSSCustomPropertyValue> CSSPropertyParser::parseTypedCustomPropertyValue(
 {
     if (syntax != "*"_s) {
         m_range.consumeWhitespace();
-        auto primitiveVal = consumeWidthOrHeight(m_range, m_context);
+        auto primitiveVal = CSSPropertyParsing::consumeWidthOrHeight(m_range, m_context);
         if (primitiveVal && primitiveVal->isPrimitiveValue() && downcast<CSSPrimitiveValue>(*primitiveVal).isLength()) {
             auto length = Style::BuilderConverter::convertLength(builderState, *primitiveVal);
             if (!length.isCalculated() && !length.isUndefined())
@@ -484,7 +484,7 @@ static RefPtr<CSSValue> consumeCounterStylePad(CSSParserTokenRange& range, const
     RefPtr<CSSValue> symbol;
     while (!integer || !symbol) {
         if (!integer) {
-            integer = consumeIntegerZeroAndGreater(range);
+            integer = consumeNonNegativeInteger(range);
             if (integer)
                 continue;
         }
@@ -524,12 +524,12 @@ static RefPtr<CSSValue> consumeCounterStyleAdditiveSymbols(CSSParserTokenRange&
     auto values = CSSValueList::createCommaSeparated();
     std::optional<int> lastWeight;
     do {
-        auto integer = consumeIntegerZeroAndGreater(range);
+        auto integer = consumeNonNegativeInteger(range);
         auto symbol = consumeCounterStyleSymbol(range, context);
         if (!integer) {
             if (!symbol)
                 return nullptr;
-            integer = consumeIntegerZeroAndGreater(range);
+            integer = consumeNonNegativeInteger(range);
             if (!integer)
                 return nullptr;
         }
@@ -639,7 +639,7 @@ bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId)
 #endif
         break;
     case CSSPropertyFontVariantCaps:
-        parsedValue = consumeFontVariantCaps(m_range);
+        parsedValue = CSSPropertyParsing::consumeFontVariantCaps(m_range);
         break;
     case CSSPropertyFontVariantLigatures:
         parsedValue = consumeFontVariantLigatures(m_range);
@@ -654,7 +654,7 @@ bool CSSPropertyParser::parseFontFaceDescriptor(CSSPropertyID propId)
         parsedValue = consumeFontVariantAlternates(m_range);
         break;
     case CSSPropertyFontVariantPosition:
-        parsedValue = consumeFontVariantPosition(m_range);
+        parsedValue = CSSPropertyParsing::consumeFontVariantPosition(m_range);
         break;
     case CSSPropertyFontVariant:
         return consumeFontVariantShorthand(false);
@@ -697,14 +697,14 @@ static RefPtr<CSSPrimitiveValue> consumeBasePaletteDescriptor(CSSParserTokenRang
 {
     if (auto result = consumeIdent<CSSValueLight, CSSValueDark>(range))
         return result;
-    return consumeIntegerZeroAndGreater(range);
+    return consumeNonNegativeInteger(range);
 }
 
 static RefPtr<CSSValueList> consumeOverrideColorsDescriptor(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
     do {
-        auto key = consumeIntegerZeroAndGreater(range);
+        auto key = consumeNonNegativeInteger(range);
         if (!key)
             return nullptr;
 
@@ -794,13 +794,13 @@ bool CSSPropertyParser::consumeFont(bool important)
     if (range.atEnd())
         return false;
 
-    fontSize = consumeFontSize(range, m_context.mode);
+    fontSize = CSSPropertyParsing::consumeFontSize(range, m_context);
     if (!fontSize || range.atEnd())
         return false;
 
     if (consumeSlashIncludingWhitespace(range)) {
         if (!consumeIdent<CSSValueNormal>(range)) {
-            lineHeight = consumeLineHeight(range, m_context.mode);
+            lineHeight = CSSPropertyParsing::consumeLineHeight(range, m_context);
             if (!lineHeight)
                 return false;
         }
@@ -882,13 +882,13 @@ bool CSSPropertyParser::consumeFontVariantShorthand(bool important)
     bool implicitNumeric = true;
     do {
         if (!capsValue) {
-            capsValue = consumeFontVariantCaps(m_range);
+            capsValue = CSSPropertyParsing::consumeFontVariantCaps(m_range);
             if (capsValue)
                 continue;
         }
         
         if (!positionValue) {
-            positionValue = consumeFontVariantPosition(m_range);
+            positionValue = CSSPropertyParsing::consumeFontVariantPosition(m_range);
             if (positionValue)
                 continue;
         }
@@ -1012,9 +1012,9 @@ bool CSSPropertyParser::consumeColumns(bool important)
             // we don't know which one(s) it is meant for. We need to see if there are other values first.
             consumeIdent(m_range);
         } else {
-            if (!columnWidth && (columnWidth = consumeColumnWidth(m_range)))
+            if (!columnWidth && (columnWidth = CSSPropertyParsing::consumeColumnWidth(m_range)))
                 continue;
-            if (!columnCount && (columnCount = consumeColumnCount(m_range)))
+            if (!columnCount && (columnCount = CSSPropertyParsing::consumeColumnCount(m_range)))
                 continue;
             // If we didn't find at least one match, this is an invalid shorthand and we have to ignore it.
             return false;
@@ -1120,7 +1120,7 @@ bool CSSPropertyParser::consumeBorder(RefPtr<CSSValue>& width, RefPtr<CSSValue>&
 {
     while (!width || !style || !color) {
         if (!width) {
-            width = consumeLineWidth(m_range, m_context.mode, UnitlessQuirk::Forbid);
+            width = CSSPropertyParsing::consumeLineWidth(m_range, m_context);
             if (width)
                 continue;
         }
@@ -1844,7 +1844,7 @@ bool CSSPropertyParser::consumeOverscrollBehaviorShorthand(bool important)
     if (m_range.atEnd())
         return false;
 
-    RefPtr<CSSValue> overscrollBehaviorX = consumeOverscrollBehavior(m_range);
+    RefPtr<CSSValue> overscrollBehaviorX = CSSPropertyParsing::consumeOverscrollBehaviorX(m_range);
     if (!overscrollBehaviorX)
         return false;
 
@@ -1853,7 +1853,7 @@ bool CSSPropertyParser::consumeOverscrollBehaviorShorthand(bool important)
     if (m_range.atEnd())
         overscrollBehaviorY = overscrollBehaviorX;
     else {
-        overscrollBehaviorY = consumeOverscrollBehavior(m_range);
+        overscrollBehaviorY = CSSPropertyParsing::consumeOverscrollBehaviorY(m_range);
         m_range.consumeWhitespace();
         if (!m_range.atEnd())
             return false;
@@ -2285,8 +2285,8 @@ bool CSSPropertyParser::parseShorthand(CSSPropertyID property, bool important)
     case CSSPropertyWebkitPerspective:
         return consumePrefixedPerspective(important);
     case CSSPropertyGap: {
-        RefPtr<CSSValue> rowGap = consumeGapLength(m_range, m_context.mode);
-        RefPtr<CSSValue> columnGap = consumeGapLength(m_range, m_context.mode);
+        auto rowGap = CSSPropertyParsing::consumeRowGap(m_range, m_context);
+        auto columnGap = CSSPropertyParsing::consumeColumnGap(m_range, m_context);
         if (!rowGap || !m_range.atEnd())
             return false;
         if (!columnGap)
diff --git a/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp b/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp
index 63a694127f56..b17eafb0744a 100644
--- a/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp
+++ b/Source/WebCore/css/parser/CSSPropertyParserHelpers.cpp
@@ -238,16 +238,14 @@ static RefPtr<CSSCalcValue> consumeCalcRawWithKnownTokenTypeFunction(CSSParserTo
 
 // MARK: Integer (Raw)
 
-enum class IntegerRange { All, ZeroAndGreater, OneAndGreater };
-
-static constexpr double computeMinimumValue(IntegerRange range)
+static constexpr double computeMinimumValue(IntegerValueRange range)
 {
     switch (range) {
-    case IntegerRange::All:
+    case IntegerValueRange::All:
         return -std::numeric_limits<double>::infinity();
-    case IntegerRange::ZeroAndGreater:
+    case IntegerValueRange::NonNegative:
         return 0.0;
-    case IntegerRange::OneAndGreater:
+    case IntegerValueRange::Positive:
         return 1.0;
     }
 
@@ -255,9 +253,10 @@ static constexpr double computeMinimumValue(IntegerRange range)
 
     return 0.0;
 }
+
 // MARK: Integer (Raw)
 
-template<typename IntType, IntegerRange integerRange>
+template<typename IntType, IntegerValueRange integerRange>
 struct IntegerTypeRawKnownTokenTypeFunctionConsumer {
     static constexpr CSSParserTokenType tokenType = FunctionToken;
     static std::optional<IntType> consume(CSSParserTokenRange& range, const CSSCalcSymbolTable&, ValueRange, CSSParserMode, UnitlessQuirk, UnitlessZeroQuirk)
@@ -274,7 +273,7 @@ struct IntegerTypeRawKnownTokenTypeFunctionConsumer {
     }
 };
 
-template<typename IntType, IntegerRange integerRange>
+template<typename IntType, IntegerValueRange integerRange>
 struct IntegerTypeRawKnownTokenTypeNumberConsumer {
     static constexpr CSSParserTokenType tokenType = NumberToken;
     static std::optional<IntType> consume(CSSParserTokenRange& range, const CSSCalcSymbolTable&, ValueRange, CSSParserMode, UnitlessQuirk, UnitlessZeroQuirk)
@@ -289,7 +288,7 @@ struct IntegerTypeRawKnownTokenTypeNumberConsumer {
 
 // MARK: Integer (CSSPrimitiveValue - maintaining calc)
 
-template<typename IntType, IntegerRange integerRange>
+template<typename IntType, IntegerValueRange integerRange>
 struct IntegerTypeKnownTokenTypeFunctionConsumer {
     static constexpr CSSParserTokenType tokenType = FunctionToken;
     static RefPtr<CSSPrimitiveValue> consume(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, CSSParserMode parserMode, UnitlessQuirk unitless, UnitlessZeroQuirk unitlessZero, CSSValuePool& pool)
@@ -302,7 +301,7 @@ struct IntegerTypeKnownTokenTypeFunctionConsumer {
     }
 };
 
-template<typename IntType, IntegerRange integerRange>
+template<typename IntType, IntegerValueRange integerRange>
 struct IntegerTypeKnownTokenTypeNumberConsumer {
     static constexpr CSSParserTokenType tokenType = NumberToken;
     static RefPtr<CSSPrimitiveValue> consume(CSSParserTokenRange& range, const CSSCalcSymbolTable& symbolTable, ValueRange valueRange, CSSParserMode parserMode, UnitlessQuirk unitless, UnitlessZeroQuirk unitlessZero, CSSValuePool& pool)
@@ -1088,7 +1087,7 @@ struct SameTokenMetaConsumer {
 
 // MARK: Integer
 
-template<typename IntType, IntegerRange integerRange>
+template<typename IntType, IntegerValueRange integerRange>
 struct IntegerTypeRawConsumer {
     using Result = std::optional<IntType>;
 
@@ -1096,7 +1095,7 @@ struct IntegerTypeRawConsumer {
     using NumberToken = IntegerTypeRawKnownTokenTypeNumberConsumer<IntType, integerRange>;
 };
 
-template<typename IntType, IntegerRange integerRange>
+template<typename IntType, IntegerValueRange integerRange>
 struct IntegerTypeConsumer {
     using Result = RefPtr<CSSPrimitiveValue>;
 
@@ -1352,44 +1351,57 @@ struct NumberOrPercentOrNoneRawAllowingSymbolTableIdentConsumer : NumberOrPercen
 
 // MARK: - Consumer functions - utilize consumer definitions above, giving more targetted interfaces and allowing exposure to other files.
 
-template<typename IntType, IntegerRange integerRange> std::optional<IntType> consumeIntegerTypeRaw(CSSParserTokenRange& range)
+template<typename IntType, IntegerValueRange integerRange> std::optional<IntType> consumeIntegerTypeRaw(CSSParserTokenRange& range)
 {
     return consumeMetaConsumer<IntegerTypeRawConsumer<IntType, integerRange>>(range, { }, ValueRange::All, CSSParserMode::HTMLStandardMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid);
 }
 
-template<typename IntType, IntegerRange integerRange> RefPtr<CSSPrimitiveValue> consumeIntegerType(CSSParserTokenRange& range, CSSValuePool& pool)
+template<typename IntType, IntegerValueRange integerRange> RefPtr<CSSPrimitiveValue> consumeIntegerType(CSSParserTokenRange& range, CSSValuePool& pool)
 {
     return consumeMetaConsumer<IntegerTypeConsumer<IntType, integerRange>>(range, { }, ValueRange::All, CSSParserMode::HTMLStandardMode, UnitlessQuirk::Forbid, UnitlessZeroQuirk::Forbid, pool);
 }
 
 std::optional<int> consumeIntegerRaw(CSSParserTokenRange& range)
 {
-    return consumeIntegerTypeRaw<int, IntegerRange::All>(range);
+    return consumeIntegerTypeRaw<int, IntegerValueRange::All>(range);
 }
 
 RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range)
 {
-    return consumeIntegerType<int, IntegerRange::All>(range, CSSValuePool::singleton());
+    return consumeIntegerType<int, IntegerValueRange::All>(range, CSSValuePool::singleton());
 }
 
-std::optional<int> consumeIntegerZeroAndGreaterRaw(CSSParserTokenRange& range)
+std::optional<int> consumeNonNegativeIntegerRaw(CSSParserTokenRange& range)
 {
-    return consumeIntegerTypeRaw<int, IntegerRange::ZeroAndGreater>(range);
+    return consumeIntegerTypeRaw<int, IntegerValueRange::NonNegative>(range);
 }
 
-RefPtr<CSSPrimitiveValue> consumeIntegerZeroAndGreater(CSSParserTokenRange& range)
+RefPtr<CSSPrimitiveValue> consumeNonNegativeInteger(CSSParserTokenRange& range)
 {
-    return consumeIntegerType<int, IntegerRange::ZeroAndGreater>(range, CSSValuePool::singleton());
+    return consumeIntegerType<int, IntegerValueRange::NonNegative>(range, CSSValuePool::singleton());
 }
 
 std::optional<unsigned> consumePositiveIntegerRaw(CSSParserTokenRange& range)
 {
-    return consumeIntegerTypeRaw<unsigned, IntegerRange::OneAndGreater>(range);
+    return consumeIntegerTypeRaw<unsigned, IntegerValueRange::Positive>(range);
 }
 
 RefPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange& range)
 {
-    return consumeIntegerType<unsigned, IntegerRange::OneAndGreater>(range, CSSValuePool::singleton());
+    return consumeIntegerType<unsigned, IntegerValueRange::Positive>(range, CSSValuePool::singleton());
+}
+
+RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange& range, IntegerValueRange valueRange)
+{
+    switch (valueRange) {
+    case IntegerValueRange::All:
+        return consumeInteger(range);
+    case IntegerValueRange::Positive:
+        return consumePositiveInteger(range);
+    case IntegerValueRange::NonNegative:
+        return consumeNonNegativeInteger(range);
+    }
+    RELEASE_ASSERT_NOT_REACHED();
 }
 
 std::optional<NumberRaw> consumeNumberRaw(CSSParserTokenRange& range, ValueRange valueRange)
@@ -3389,7 +3401,7 @@ std::optional<PositionCoordinates> consumeOneOrTwoValuedPositionCoordinates(CSSP
     return positionFromTwoValues(*value1, *value2);
 }
 
-RefPtr<CSSPrimitiveValue> consumeSingleAxisPosition(CSSParserTokenRange& range, CSSParserMode parserMode, BoxOrient orientation)
+static RefPtr<CSSPrimitiveValue> consumeSingleAxisPosition(CSSParserTokenRange& range, CSSParserMode parserMode, BoxOrient orientation)
 {
     RefPtr<CSSPrimitiveValue> value1;
 
@@ -4603,7 +4615,7 @@ RefPtr<CSSValue> consumeImage(CSSParserTokenRange& range, const CSSParserContext
 }
 
 // https://www.w3.org/TR/css-counter-styles-3/#predefined-counters
-bool isPredefinedCounterStyle(CSSValueID valueID)
+static bool isPredefinedCounterStyle(CSSValueID valueID)
 {
     return valueID >= CSSValueDisc && valueID <= CSSValueEthiopicNumeric;
 }
@@ -4656,7 +4668,7 @@ RefPtr<CSSPrimitiveValue> consumeSingleContainerName(CSSParserTokenRange& range)
     }
 }
 
-std::optional<FontWeightRaw> consumeFontWeightRaw(CSSParserTokenRange& range)
+static std::optional<FontWeightRaw> consumeFontWeightRaw(CSSParserTokenRange& range)
 {
     if (auto result = consumeIdentRaw<CSSValueNormal, CSSValueBold, CSSValueBolder, CSSValueLighter>(range))
         return { *result };
@@ -4670,7 +4682,7 @@ std::optional<CSSValueID> consumeFontStretchKeywordValueRaw(CSSParserTokenRange&
     return consumeIdentRaw<CSSValueUltraCondensed, CSSValueExtraCondensed, CSSValueCondensed, CSSValueSemiCondensed, CSSValueNormal, CSSValueSemiExpanded, CSSValueExpanded, CSSValueExtraExpanded, CSSValueUltraExpanded>(range);
 }
 
-std::optional<FontStyleRaw> consumeFontStyleRaw(CSSParserTokenRange& range, CSSParserMode parserMode)
+static std::optional<FontStyleRaw> consumeFontStyleRaw(CSSParserTokenRange& range, CSSParserMode parserMode)
 {
 #if ENABLE(VARIATION_FONTS)
     CSSParserTokenRange rangeBeforeKeyword = range;
@@ -4930,34 +4942,6 @@ RefPtr<CSSValue> consumeAspectRatio(CSSParserTokenRange& range)
     return list;
 }
 
-RefPtr<CSSValue> consumeAutoOrString(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumeString(range);
-}
-
-RefPtr<CSSValue> consumeAutoOrColor(CSSParserTokenRange& range, const CSSParserContext& context)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumeColor(range, context);
-}
-
-RefPtr<CSSValue> consumeAutoOrPosition(CSSParserTokenRange& range, CSSParserMode parserMode, UnitlessQuirk unitless, PositionSyntax positionSyntax)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumePosition(range, parserMode, unitless, positionSyntax);
-}
-
-RefPtr<CSSValue> consumeNoneOrURL(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueNone)
-        return consumeIdent(range);
-    return consumeURL(range);
-}
-
 RefPtr<CSSValue> consumeDisplay(CSSParserTokenRange& range)
 {
     // Parse single keyword values
@@ -5159,13 +5143,6 @@ RefPtr<CSSValue> consumeFontVariationSettings(CSSParserTokenRange& range)
 
 #endif // ENABLE(VARIATION_FONTS)
 
-RefPtr<CSSValue> consumePage(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumeCustomIdent(range);
-}
-
 RefPtr<CSSValue> consumeQuotes(CSSParserTokenRange& range)
 {
     auto id = range.peek().id();
@@ -5319,13 +5296,6 @@ RefPtr<CSSValue> consumeFontVariantEastAsian(CSSParserTokenRange& range)
     return values;
 }
 
-RefPtr<CSSValue> consumeFontVariantCaps(CSSParserTokenRange& range)
-{
-    return consumeIdent<CSSValueNormal, CSSValueSmallCaps, CSSValueAllSmallCaps,
-        CSSValuePetiteCaps, CSSValueAllPetiteCaps,
-        CSSValueUnicase, CSSValueTitlingCaps>(range);
-}
-
 RefPtr<CSSValue> consumeFontVariantAlternates(CSSParserTokenRange& range)
 {
     if (range.atEnd())
@@ -5416,11 +5386,6 @@ RefPtr<CSSValue> consumeFontVariantAlternates(CSSParserTokenRange& range)
     return nullptr;
 }
 
-RefPtr<CSSValue> consumeFontVariantPosition(CSSParserTokenRange& range)
-{
-    return consumeIdent<CSSValueNormal, CSSValueSub, CSSValueSuper>(range);
-}
-
 RefPtr<CSSValue> consumeFontVariantNumeric(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueNormal)
@@ -5447,13 +5412,6 @@ RefPtr<CSSValue> consumeFontWeight(CSSParserTokenRange& range)
     return nullptr;
 }
 
-RefPtr<CSSValue> consumeFontPalette(CSSParserTokenRange& range)
-{
-    if (auto result = consumeIdent<CSSValueNormal, CSSValueLight, CSSValueDark>(range))
-        return result;
-    return consumeDashedIdent(range);
-}
-
 RefPtr<CSSValue> consumeFamilyName(CSSParserTokenRange& range)
 {
     auto familyName = consumeFamilyNameRaw(range);
@@ -5501,70 +5459,6 @@ RefPtr<CSSValue> consumeFontFamilyDescriptor(CSSParserTokenRange& range)
     return list;
 }
 
-RefPtr<CSSValue> consumeLetterSpacing(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (range.peek().id() == CSSValueNormal)
-        return consumeIdent(range);
-    return consumeLength(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
-}
-
-RefPtr<CSSValue> consumeWordSpacing(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (range.peek().id() == CSSValueNormal)
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
-}
-    
-RefPtr<CSSValue> consumeTabSize(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    auto tabSize = consumeNumber(range, ValueRange::NonNegative);
-    if (tabSize)
-        return tabSize;
-    return consumeLength(range, cssParserMode, ValueRange::NonNegative);
-}
-
-#if ENABLE(TEXT_AUTOSIZING)
-RefPtr<CSSValue> consumeTextSizeAdjust(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    if (range.peek().id() == CSSValueNone)
-        return consumeIdent(range);
-    return consumePercent(range, ValueRange::NonNegative);
-}
-#endif
-
-RefPtr<CSSValue> consumeFontSize(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
-{
-    // -webkit-xxx-large is a parse-time alias.
-    if (range.peek().id() == CSSValueWebkitXxxLarge) {
-        consumeIdent(range);
-        return CSSValuePool::singleton().createValue(CSSValueXxxLarge);
-    }
-
-    if (range.peek().id() >= CSSValueXxSmall && range.peek().id() <= CSSValueLarger)
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative, unitless);
-}
-
-RefPtr<CSSValue> consumeFontSizeAdjust(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueNone)
-        return consumeIdent(range);
-    return consumeNumber(range, ValueRange::NonNegative);
-}
-
-RefPtr<CSSValue> consumeLineHeight(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (range.peek().id() == CSSValueNormal)
-        return consumeIdent(range);
-
-    RefPtr<CSSPrimitiveValue> lineHeight = consumeNumber(range, ValueRange::NonNegative);
-    if (lineHeight)
-        return lineHeight;
-    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
-}
-
 static RefPtr<CSSValue> consumeCounter(CSSParserTokenRange& range, int defaultValue)
 {
     if (range.peek().id() == CSSValueNone)
@@ -5671,13 +5565,6 @@ RefPtr<CSSValue> consumeTextIndent(CSSParserTokenRange& range, CSSParserMode css
     return list;
 }
 
-RefPtr<CSSValue> consumeScrollPadding(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
-}
-
 static bool validWidthOrHeightKeyword(CSSValueID id)
 {
     switch (id) {
@@ -5696,21 +5583,7 @@ static bool validWidthOrHeightKeyword(CSSValueID id)
     }
 }
 
-RefPtr<CSSValue> consumeMaxWidthOrHeight(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless)
-{
-    if (range.peek().id() == CSSValueNone || validWidthOrHeightKeyword(range.peek().id()))
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, context.mode, ValueRange::NonNegative, unitless);
-}
-
-RefPtr<CSSValue> consumeWidthOrHeight(CSSParserTokenRange& range, const CSSParserContext& context, UnitlessQuirk unitless)
-{
-    if (range.peek().id() == CSSValueAuto || validWidthOrHeightKeyword(range.peek().id()))
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, context.mode, ValueRange::NonNegative, unitless);
-}
-
-RefPtr<CSSValue> consumeMarginOrOffset(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+static RefPtr<CSSValue> consumeAutoOrLengthOrPercent(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
 {
     if (range.peek().id() == CSSValueAuto)
         return consumeIdent(range);
@@ -5720,13 +5593,13 @@ RefPtr<CSSValue> consumeMarginOrOffset(CSSParserTokenRange& range, CSSParserMode
 RefPtr<CSSValue> consumeMarginSide(CSSParserTokenRange& range, CSSPropertyID currentShorthand, CSSParserMode cssParserMode)
 {
     UnitlessQuirk unitless = currentShorthand != CSSPropertyInset ? UnitlessQuirk::Allow : UnitlessQuirk::Forbid;
-    return consumeMarginOrOffset(range, cssParserMode, unitless);
+    return consumeAutoOrLengthOrPercent(range, cssParserMode, unitless);
 }
 
 RefPtr<CSSValue> consumeSide(CSSParserTokenRange& range, CSSPropertyID currentShorthand, CSSParserMode cssParserMode)
 {
     UnitlessQuirk unitless = currentShorthand != CSSPropertyInset ? UnitlessQuirk::Allow : UnitlessQuirk::Forbid;
-    return consumeMarginOrOffset(range, cssParserMode, unitless);
+    return consumeAutoOrLengthOrPercent(range, cssParserMode, unitless);
 }
 
 static RefPtr<CSSPrimitiveValue> consumeClipComponent(CSSParserTokenRange& range, CSSParserMode cssParserMode)
@@ -5789,58 +5662,6 @@ RefPtr<CSSValue> consumeTouchAction(CSSParserTokenRange& range)
     return list;
 }
 
-RefPtr<CSSValue> consumeWebkitLineClamp(CSSParserTokenRange& range)
-{
-    if (auto clampValue = consumePercent(range, ValueRange::NonNegative))
-        return clampValue;
-    // When specifying number of lines, don't allow 0 as a valid value.
-    return consumePositiveInteger(range);
-}
-
-RefPtr<CSSValue> consumeHyphenateLimit(CSSParserTokenRange& range, CSSValueID valueID)
-{
-    if (range.peek().id() == valueID)
-        return consumeIdent(range);
-    return consumeNumber(range, ValueRange::NonNegative);
-}
-
-RefPtr<CSSValue> consumeColumnWidth(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    // Always parse lengths in strict mode here, since it would be ambiguous otherwise when used in
-    // the 'columns' shorthand property.
-    return consumeLength(range, HTMLStandardMode, ValueRange::NonNegative);
-}
-
-RefPtr<CSSValue> consumeColumnCount(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumePositiveInteger(range);
-}
-
-RefPtr<CSSValue> consumeGapLength(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (range.peek().id() == CSSValueNormal)
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
-}
-
-RefPtr<CSSValue> consumeZoom(CSSParserTokenRange& range)
-{
-    const CSSParserToken& token = range.peek();
-    RefPtr<CSSPrimitiveValue> zoom;
-    if (token.type() == IdentToken)
-        zoom = consumeIdent<CSSValueNormal, CSSValueReset, CSSValueDocument>(range);
-    else {
-        zoom = consumePercent(range, ValueRange::NonNegative);
-        if (!zoom)
-            zoom = consumeNumber(range, ValueRange::NonNegative);
-    }
-    return zoom;
-}
-
 RefPtr<CSSValue> consumeAnimationIterationCount(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueInfinite)
@@ -6112,13 +5933,6 @@ RefPtr<CSSValue> consumeAnimationPropertyList(CSSPropertyID property, CSSParserT
     return singleton;
 }
 
-RefPtr<CSSValue> consumeZIndex(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumeInteger(range);
-}
-
 RefPtr<CSSValue> consumeShadow(CSSParserTokenRange& range, const CSSParserContext& context, bool isBoxShadowProperty)
 {
     if (range.peek().id() == CSSValueNone)
@@ -6196,27 +6010,15 @@ RefPtr<CSSValue> consumeTextEmphasisStyle(CSSParserTokenRange& range)
     return nullptr;
 }
 
-RefPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange& range, const CSSParserContext& context)
-{
-    // Allow the special focus color even in HTML Standard parsing mode.
-    if (range.peek().id() == CSSValueWebkitFocusRingColor)
-        return consumeIdent(range);
-    return consumeColor(range, context);
-}
-
-RefPtr<CSSValue> consumeLineWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode, UnitlessQuirk unitless)
+RefPtr<CSSValue> consumeBorderWidth(CSSParserTokenRange& range, CSSPropertyID currentShorthand, const CSSParserContext& context)
 {
     CSSValueID id = range.peek().id();
     if (id == CSSValueThin || id == CSSValueMedium || id == CSSValueThick)
         return consumeIdent(range);
-    return consumeLength(range, cssParserMode, ValueRange::NonNegative, unitless);
-}
 
-RefPtr<CSSValue> consumeBorderWidth(CSSParserTokenRange& range, CSSPropertyID currentShorthand, const CSSParserContext& context)
-{
     bool allowQuirkyLengths = (context.mode == HTMLQuirksMode) && (currentShorthand == CSSPropertyInvalid || currentShorthand == CSSPropertyBorderWidth);
     UnitlessQuirk unitless = allowQuirkyLengths ? UnitlessQuirk::Allow : UnitlessQuirk::Forbid;
-    return consumeLineWidth(range, context.mode, unitless);
+    return consumeLength(range, context.mode, ValueRange::NonNegative, unitless);
 }
 
 RefPtr<CSSValue> consumeBorderColor(CSSParserTokenRange& range, CSSPropertyID currentShorthand, const CSSParserContext& context)
@@ -6225,23 +6027,6 @@ RefPtr<CSSValue> consumeBorderColor(CSSParserTokenRange& range, CSSPropertyID cu
     return consumeColor(range, context, allowQuirkyColors);
 }
 
-RefPtr<CSSValue> consumeTextStrokeWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
-}
-
-RefPtr<CSSValue> consumeColumnRuleWidth(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    return consumeLineWidth(range, cssParserMode, UnitlessQuirk::Forbid);
-}
-
-RefPtr<CSSValue> consumeOpacity(CSSParserTokenRange& range)
-{
-    if (auto parsedValue = consumeNumber(range, ValueRange::All))
-        return parsedValue;
-    return consumePercent(range, ValueRange::All);
-}
-
 static bool consumeTranslate3d(CSSParserTokenRange& args, CSSParserMode cssParserMode, RefPtr<CSSFunctionValue>& transformValue)
 {
     unsigned numberOfArguments = 2;
@@ -6657,18 +6442,6 @@ RefPtr<CSSValue> consumePaintStroke(CSSParserTokenRange& range, const CSSParserC
     return consumeColor(range, context);
 }
 
-RefPtr<CSSValue> consumeGlyphOrientationHorizontal(CSSParserTokenRange& range, CSSParserMode mode)
-{
-    return consumeAngle(range, mode, UnitlessQuirk::Allow, UnitlessZeroQuirk::Allow);
-}
-
-RefPtr<CSSValue> consumeGlyphOrientationVertical(CSSParserTokenRange& range, CSSParserMode mode)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumeAngle(range, mode, UnitlessQuirk::Allow, UnitlessZeroQuirk::Allow);
-}
-
 RefPtr<CSSValue> consumePaintOrder(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueNormal)
@@ -6725,20 +6498,6 @@ bool isFlexBasisIdent(CSSValueID id)
     return identMatches<CSSValueAuto, CSSValueContent>(id) || validWidthOrHeightKeyword(id);
 }
 
-RefPtr<CSSValue> consumeFlexBasis(CSSParserTokenRange& range, const CSSParserContext& context)
-{
-    if (isFlexBasisIdent(range.peek().id()))
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, context.mode, ValueRange::NonNegative);
-}
-
-RefPtr<CSSValue> consumeKerning(CSSParserTokenRange& range, CSSParserMode mode)
-{
-    if (auto result = consumeIdent<CSSValueAuto, CSSValueNormal>(range))
-        return result;
-    return consumeLength(range, mode, ValueRange::All, UnitlessQuirk::Allow);
-}
-
 RefPtr<CSSValue> consumeStrokeDasharray(CSSParserTokenRange& range)
 {
     CSSValueID id = range.peek().id();
@@ -6755,21 +6514,6 @@ RefPtr<CSSValue> consumeStrokeDasharray(CSSParserTokenRange& range)
     return dashes;
 }
 
-RefPtr<CSSValue> consumeBaselineShift(CSSParserTokenRange& range)
-{
-    CSSValueID id = range.peek().id();
-    if (id == CSSValueBaseline || id == CSSValueSub || id == CSSValueSuper)
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, SVGAttributeMode, ValueRange::All);
-}
-
-RefPtr<CSSValue> consumeRxOrRy(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (range.peek().id() == CSSValueAuto)
-        return consumeIdent(range);
-    return consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Forbid);
-}
-
 RefPtr<CSSValue> consumeCursor(CSSParserTokenRange& range, const CSSParserContext& context, bool inQuirksMode)
 {
     RefPtr<CSSValueList> list;
@@ -6939,14 +6683,6 @@ RefPtr<CSSValue> consumeScrollSnapType(CSSParserTokenRange& range)
     return typeValue;
 }
 
-RefPtr<CSSValue> consumeOverscrollBehavior(CSSParserTokenRange& range)
-{
-    auto valueID = range.peek().id();
-    if (valueID != CSSValueAuto && valueID != CSSValueNone && valueID != CSSValueContain)
-        return nullptr;
-    return consumeIdent(range);
-}
-
 RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParserMode cssParserMode)
 {
     RefPtr<CSSPrimitiveValue> parsedValue1 = consumeLengthOrPercent(range, cssParserMode, ValueRange::NonNegative);
@@ -6958,28 +6694,6 @@ RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange& range, CSSParser
     return createPrimitiveValuePair(parsedValue1.releaseNonNull(), parsedValue2.releaseNonNull(), Pair::IdenticalValueEncoding::Coalesce);
 }
 
-RefPtr<CSSValue> consumeTextUnderlineOffset(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (auto value = consumeIdent<CSSValueAuto>(range))
-        return value;
-    return consumeLength(range, cssParserMode, ValueRange::All);
-}
-
-RefPtr<CSSValue> consumeTextDecorationThickness(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    if (auto value = consumeIdent<CSSValueAuto, CSSValueFromFont>(range))
-        return value;
-    return consumeLength(range, cssParserMode, ValueRange::All);
-}
-
-RefPtr<CSSValue> consumeVerticalAlign(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    RefPtr<CSSPrimitiveValue> parsedValue = consumeIdentRange(range, CSSValueBaseline, CSSValueWebkitBaselineMiddle);
-    if (!parsedValue)
-        parsedValue = consumeLengthOrPercent(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
-    return parsedValue;
-}
-
 static RefPtr<CSSPrimitiveValue> consumeShapeRadius(CSSParserTokenRange& args, CSSParserMode cssParserMode)
 {
     if (identMatches<CSSValueClosestSide, CSSValueFarthestSide>(args.peek().id()))
@@ -8319,13 +8033,6 @@ RefPtr<CSSValue> consumeLineBoxContain(CSSParserTokenRange& range)
     return CSSLineBoxContainValue::create(lineBoxContain);
 }
 
-RefPtr<CSSValue> consumeWebkitLineGrid(CSSParserTokenRange& range)
-{
-    if (range.peek().id() == CSSValueNone)
-        return consumeIdent(range);
-    return consumeCustomIdent(range);
-}
-
 RefPtr<CSSValue> consumeContainerName(CSSParserTokenRange& range)
 {
     if (range.peek().id() == CSSValueNone)
@@ -8452,21 +8159,6 @@ RefPtr<CSSValue> consumeHangingPunctuation(CSSParserTokenRange& range)
     return list->length() ? list : nullptr;
 }
 
-RefPtr<CSSValue> consumeWebkitMarqueeIncrement(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    return consumeLengthOrPercent(range, cssParserMode, ValueRange::All, UnitlessQuirk::Allow);
-}
-
-RefPtr<CSSValue> consumeWebkitMarqueeRepetition(CSSParserTokenRange& range)
-{
-    return consumeNumber(range, ValueRange::NonNegative);
-}
-
-RefPtr<CSSValue> consumeWebkitMarqueeSpeed(CSSParserTokenRange& range, CSSParserMode cssParserMode)
-{
-    return consumeTime(range, cssParserMode, ValueRange::NonNegative, UnitlessQuirk::Allow);
-}
-
 RefPtr<CSSValue> consumeAlt(CSSParserTokenRange& range, const CSSParserContext& context)
 {
     if (range.peek().type() == StringToken)
@@ -8653,13 +8345,6 @@ RefPtr<CSSValue> consumeColorScheme(CSSParserTokenRange& range)
 
 #endif
 
-RefPtr<CSSValue> consumeListStyleType(CSSParserTokenRange& range, const CSSParserContext& context)
-{
-    if (CSSPropertyParsing::isKeywordValidForProperty(CSSPropertyListStyleType, range.peek().id(), context))
-        return consumeIdent(range);
-    return consumeString(range);
-}
-
 RefPtr<CSSValue> consumeOffsetRotate(CSSParserTokenRange& range, CSSParserMode mode)
 {
     RefPtr<CSSPrimitiveValue> modifier;
diff --git a/Source/WebCore/css/parser/CSSPropertyParserHelpers.h b/Source/WebCore/css/parser/CSSPropertyParserHelpers.h
index 2993538d3646..e732e0067c31 100644
--- a/Source/WebCore/css/parser/CSSPropertyParserHelpers.h
+++ b/Source/WebCore/css/parser/CSSPropertyParserHelpers.h
@@ -68,8 +68,10 @@ CSSParserTokenRange consumeFunction(CSSParserTokenRange&);
 
 enum class NegativePercentagePolicy : bool { Forbid, Allow };
 
-enum class UnitlessQuirk { Allow, Forbid };
-enum class UnitlessZeroQuirk { Allow, Forbid };
+enum class UnitlessQuirk : bool { Allow, Forbid };
+enum class UnitlessZeroQuirk : bool { Allow, Forbid };
+
+enum class IntegerValueRange : uint8_t { All, Positive, NonNegative };
 
 struct NoneRaw { };
 
@@ -95,28 +97,36 @@ using LengthOrPercentRaw = std::variant<LengthRaw, PercentRaw>;
 
 std::optional<int> consumeIntegerRaw(CSSParserTokenRange&);
 RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange&);
-std::optional<int> consumeIntegerZeroAndGreaterRaw(CSSParserTokenRange&);
-RefPtr<CSSPrimitiveValue> consumeIntegerZeroAndGreater(CSSParserTokenRange&);
+std::optional<int> consumeNonNegativeIntegerRaw(CSSParserTokenRange&);
+RefPtr<CSSPrimitiveValue> consumeNonNegativeInteger(CSSParserTokenRange&);
 std::optional<unsigned> consumePositiveIntegerRaw(CSSParserTokenRange&);
 RefPtr<CSSPrimitiveValue> consumePositiveInteger(CSSParserTokenRange&);
+RefPtr<CSSPrimitiveValue> consumeInteger(CSSParserTokenRange&, IntegerValueRange);
+
 std::optional<NumberRaw> consumeNumberRaw(CSSParserTokenRange&, ValueRange = ValueRange::All);
 RefPtr<CSSPrimitiveValue> consumeNumber(CSSParserTokenRange&, ValueRange);
 RefPtr<CSSPrimitiveValue> consumeNumberOrPercent(CSSParserTokenRange&, ValueRange);
-RefPtr<CSSPrimitiveValue> consumeFontWeightNumberWorkerSafe(CSSParserTokenRange&, CSSValuePool&);
+
 RefPtr<CSSPrimitiveValue> consumeLength(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
+RefPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid, NegativePercentagePolicy = NegativePercentagePolicy::Forbid);
+
 RefPtr<CSSPrimitiveValue> consumePercent(CSSParserTokenRange&, ValueRange);
 RefPtr<CSSPrimitiveValue> consumePercentWorkerSafe(CSSParserTokenRange&, ValueRange, CSSValuePool&);
-RefPtr<CSSPrimitiveValue> consumeLengthOrPercent(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid, NegativePercentagePolicy = NegativePercentagePolicy::Forbid);
+
 RefPtr<CSSPrimitiveValue> consumeAngle(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk = UnitlessQuirk::Forbid, UnitlessZeroQuirk = UnitlessZeroQuirk::Forbid);
 RefPtr<CSSPrimitiveValue> consumeAngleWorkerSafe(CSSParserTokenRange&, CSSParserMode, CSSValuePool&, UnitlessQuirk = UnitlessQuirk::Forbid, UnitlessZeroQuirk = UnitlessZeroQuirk::Forbid);
+
 RefPtr<CSSPrimitiveValue> consumeTime(CSSParserTokenRange&, CSSParserMode, ValueRange, UnitlessQuirk = UnitlessQuirk::Forbid);
+
 RefPtr<CSSPrimitiveValue> consumeResolution(CSSParserTokenRange&);
 
+RefPtr<CSSPrimitiveValue> consumeFontWeightNumberWorkerSafe(CSSParserTokenRange&, CSSValuePool&);
+
 std::optional<CSSValueID> consumeIdentRaw(CSSParserTokenRange&);
 RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange&);
 RefPtr<CSSPrimitiveValue> consumeIdentWorkerSafe(CSSParserTokenRange&, CSSValuePool&);
 RefPtr<CSSPrimitiveValue> consumeIdentRange(CSSParserTokenRange&, CSSValueID lower, CSSValueID upper);
-template<CSSValueID, CSSValueID...> inline bool identMatches(CSSValueID id);
+template<CSSValueID, CSSValueID...> bool identMatches(CSSValueID id);
 template<CSSValueID... allowedIdents> std::optional<CSSValueID> consumeIdentRaw(CSSParserTokenRange&);
 template<CSSValueID... allowedIdents> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange&);
 template<CSSValueID... allowedIdents> RefPtr<CSSPrimitiveValue> consumeIdentWorkerSafe(CSSParserTokenRange&, CSSValuePool&);
@@ -127,6 +137,7 @@ template<typename Predicate, typename... Args> RefPtr<CSSPrimitiveValue> consume
 RefPtr<CSSPrimitiveValue> consumeCustomIdent(CSSParserTokenRange&, bool shouldLowercase = false);
 RefPtr<CSSPrimitiveValue> consumeDashedIdent(CSSParserTokenRange&, bool shouldLowercase = false);
 RefPtr<CSSPrimitiveValue> consumeString(CSSParserTokenRange&);
+
 StringView consumeURLRaw(CSSParserTokenRange&);
 RefPtr<CSSPrimitiveValue> consumeURL(CSSParserTokenRange&);
 
@@ -144,7 +155,6 @@ struct PositionCoordinates {
 };
 
 RefPtr<CSSPrimitiveValue> consumePosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, PositionSyntax);
-RefPtr<CSSPrimitiveValue> consumeSingleAxisPosition(CSSParserTokenRange&, CSSParserMode, BoxOrient);
 std::optional<PositionCoordinates> consumePositionCoordinates(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, PositionSyntax, NegativePercentagePolicy = NegativePercentagePolicy::Forbid);
 std::optional<PositionCoordinates> consumeOneOrTwoValuedPositionCoordinates(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk);
 
@@ -185,14 +195,11 @@ struct FontRaw {
     Vector<FontFamilyRaw> family;
 };
 
-bool isPredefinedCounterStyle(CSSValueID);
 RefPtr<CSSPrimitiveValue> consumeCounterStyleName(CSSParserTokenRange&);
 AtomString consumeCounterStyleNameInPrelude(CSSParserTokenRange&);
 RefPtr<CSSPrimitiveValue> consumeSingleContainerName(CSSParserTokenRange&);
 
-std::optional<FontWeightRaw> consumeFontWeightRaw(CSSParserTokenRange&);
 std::optional<CSSValueID> consumeFontStretchKeywordValueRaw(CSSParserTokenRange&);
-std::optional<FontStyleRaw> consumeFontStyleRaw(CSSParserTokenRange&, CSSParserMode);
 AtomString concatenateFamilyName(CSSParserTokenRange&);
 AtomString consumeFamilyNameRaw(CSSParserTokenRange&);
 // https://drafts.csswg.org/css-fonts-4/#family-name-value
@@ -206,86 +213,7 @@ bool isFontStyleAngleInRange(double angleInDegrees);
 RefPtr<CSSValueList> consumeAspectRatioValue(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeAspectRatio(CSSParserTokenRange&);
 
-// Template and inline implementations are at the bottom of the file for readability.
-
-template<typename... emptyBaseCase> inline bool identMatches(CSSValueID) { return false; }
-template<CSSValueID head, CSSValueID... tail> inline bool identMatches(CSSValueID id)
-{
-    return id == head || identMatches<tail...>(id);
-}
-
-template<CSSValueID... names> std::optional<CSSValueID> consumeIdentRaw(CSSParserTokenRange& range)
-{
-    if (range.peek().type() != IdentToken || !identMatches<names...>(range.peek().id()))
-        return std::nullopt;
-    return range.consumeIncludingWhitespace().id();
-}
-
-template<CSSValueID... names> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
-{
-    return consumeIdentWorkerSafe<names...>(range, CSSValuePool::singleton());
-}
-
-template<CSSValueID... names> RefPtr<CSSPrimitiveValue> consumeIdentWorkerSafe(CSSParserTokenRange& range, CSSValuePool& cssValuePool)
-{
-    if (range.peek().type() != IdentToken || !identMatches<names...>(range.peek().id()))
-        return nullptr;
-    return cssValuePool.createIdentifierValue(range.consumeIncludingWhitespace().id());
-}
-
-template<typename Predicate, typename... Args> std::optional<CSSValueID> consumeIdentRaw(CSSParserTokenRange& range, Predicate&& predicate, Args&&... args)
-{
-    if (auto keyword = range.peek().id(); predicate(keyword, std::forward<Args>(args)...)) {
-        range.consumeIncludingWhitespace();
-        return keyword;
-    }
-    return std::nullopt;
-}
-
-template<typename Predicate, typename... Args> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range, Predicate&& predicate, Args&&... args)
-{
-    return consumeIdentWorkerSafe(range, CSSValuePool::singleton(), std::forward<Predicate>(predicate), std::forward<Args>(args)...);
-}
-
-template<typename Predicate, typename... Args> RefPtr<CSSPrimitiveValue> consumeIdentWorkerSafe(CSSParserTokenRange& range, CSSValuePool& cssValuePool, Predicate&& predicate, Args&&... args)
-{
-    if (auto keyword = range.peek().id(); predicate(keyword, std::forward<Args>(args)...)) {
-        range.consumeIncludingWhitespace();
-        return cssValuePool.createIdentifierValue(keyword);
-    }
-    return nullptr;
-}
-
-inline bool isFontStyleAngleInRange(double angleInDegrees)
-{
-    return angleInDegrees >= -90 && angleInDegrees <= 90;
-}
-
-inline bool isSystemFontShorthand(CSSValueID valueID)
-{
-    // This needs to stay in sync with SystemFontDatabase::FontShorthand.
-    static_assert(CSSValueStatusBar - CSSValueCaption == static_cast<SystemFontDatabase::FontShorthandUnderlyingType>(SystemFontDatabase::FontShorthand::StatusBar));
-    return valueID >= CSSValueCaption && valueID <= CSSValueStatusBar;
-}
-
-inline SystemFontDatabase::FontShorthand lowerFontShorthand(CSSValueID valueID)
-{
-    // This needs to stay in sync with SystemFontDatabase::FontShorthand.
-    ASSERT(isSystemFontShorthand(valueID));
-    return static_cast<SystemFontDatabase::FontShorthand>(valueID - CSSValueCaption);
-}
-
-template<typename... Args>
-Ref<CSSPrimitiveValue> createPrimitiveValuePair(Args&&... args)
-{
-    return CSSValuePool::singleton().createValue(Pair::create(std::forward<Args>(args)...));
-}
-
-RefPtr<CSSValue> consumeAutoOrString(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeAutoOrColor(CSSParserTokenRange&, const CSSParserContext&);
-RefPtr<CSSValue> consumeAutoOrPosition(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk, PositionSyntax);
-RefPtr<CSSValue> consumeNoneOrURL(CSSParserTokenRange&);
-
+using IsPositionKeyword = bool (*)(CSSValueID);
 bool isFlexBasisIdent(CSSValueID);
 bool isBaselineKeyword(CSSValueID);
 bool isContentPositionKeyword(CSSValueID);
@@ -293,53 +221,28 @@ bool isContentPositionOrLeftOrRightKeyword(CSSValueID);
 bool isSelfPositionKeyword(CSSValueID);
 bool isSelfPositionOrLeftOrRightKeyword(CSSValueID);
 
-using IsPositionKeyword = bool (*)(CSSValueID);
-
 RefPtr<CSSValue> consumeDisplay(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeWillChange(CSSParserTokenRange&, const CSSParserContext&);
 #if ENABLE(VARIATION_FONTS)
 RefPtr<CSSValue> consumeFontVariationSettings(CSSParserTokenRange&);
 #endif
-RefPtr<CSSValue> consumePage(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeQuotes(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFontVariantLigatures(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFontVariantEastAsian(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeFontVariantCaps(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFontVariantAlternates(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeFontVariantPosition(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFontVariantNumeric(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFontWeight(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeFontPalette(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFamilyName(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFontFamily(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeFontFamilyDescriptor(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeLetterSpacing(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeWordSpacing(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeTabSize(CSSParserTokenRange&, CSSParserMode);
-#if ENABLE(TEXT_AUTOSIZING)
-RefPtr<CSSValue> consumeTextSizeAdjust(CSSParserTokenRange&);
-#endif
-RefPtr<CSSValue> consumeFontSize(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk = UnitlessQuirk::Forbid);
-RefPtr<CSSValue> consumeFontSizeAdjust(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeLineHeight(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeCounterIncrement(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeCounterReset(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeSize(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeTextIndent(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeScrollPadding(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeMaxWidthOrHeight(CSSParserTokenRange&, const CSSParserContext&, UnitlessQuirk = UnitlessQuirk::Forbid);
-RefPtr<CSSValue> consumeWidthOrHeight(CSSParserTokenRange&, const CSSParserContext&, UnitlessQuirk = UnitlessQuirk::Forbid);
-RefPtr<CSSValue> consumeMarginOrOffset(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk);
 RefPtr<CSSValue> consumeMarginSide(CSSParserTokenRange&, CSSPropertyID currentShorthand, CSSParserMode);
 RefPtr<CSSValue> consumeSide(CSSParserTokenRange&, CSSPropertyID currentShorthand, CSSParserMode);
 RefPtr<CSSValue> consumeClip(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeTouchAction(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeWebkitLineClamp(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeHyphenateLimit(CSSParserTokenRange&, CSSValueID);
-RefPtr<CSSValue> consumeColumnWidth(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeColumnCount(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeGapLength(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeZoom(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeAnimationIterationCount(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeAnimationName(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeTransitionProperty(CSSParserTokenRange&);
@@ -350,20 +253,14 @@ RefPtr<CSSValue> consumeAnimationTimingFunction(CSSParserTokenRange&, const CSSP
 RefPtr<CSSValue> consumeAnimationValue(CSSPropertyID, CSSParserTokenRange&, const CSSParserContext&);
 bool isValidAnimationPropertyList(CSSPropertyID, const CSSValueList&);
 RefPtr<CSSValue> consumeAnimationPropertyList(CSSPropertyID, CSSParserTokenRange&, const CSSParserContext&);
-RefPtr<CSSValue> consumeZIndex(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeShadow(CSSParserTokenRange&, const CSSParserContext&, bool isBoxShadowProperty);
 RefPtr<CSSValue> consumeTextShadow(CSSParserTokenRange&, const CSSParserContext&);
 RefPtr<CSSValue> consumeBoxShadow(CSSParserTokenRange&, const CSSParserContext&);
 RefPtr<CSSValue> consumeWebkitBoxShadow(CSSParserTokenRange&, const CSSParserContext&);
 RefPtr<CSSValue> consumeTextDecorationLine(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeTextEmphasisStyle(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeOutlineColor(CSSParserTokenRange&, const CSSParserContext&);
-RefPtr<CSSValue> consumeLineWidth(CSSParserTokenRange&, CSSParserMode, UnitlessQuirk);
 RefPtr<CSSValue> consumeBorderWidth(CSSParserTokenRange&, CSSPropertyID currentShorthand, const CSSParserContext&);
 RefPtr<CSSValue> consumeBorderColor(CSSParserTokenRange&, CSSPropertyID currentShorthand, const CSSParserContext&);
-RefPtr<CSSValue> consumeTextStrokeWidth(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeColumnRuleWidth(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeOpacity(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeTransformValue(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeTransform(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeTranslate(CSSParserTokenRange&, CSSParserMode);
@@ -372,14 +269,8 @@ RefPtr<CSSValue> consumeRotate(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumePositionX(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumePositionY(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumePaintStroke(CSSParserTokenRange&, const CSSParserContext&);
-RefPtr<CSSValue> consumeGlyphOrientationHorizontal(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeGlyphOrientationVertical(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumePaintOrder(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeFlexBasis(CSSParserTokenRange&, const CSSParserContext&);
-RefPtr<CSSValue> consumeKerning(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeStrokeDasharray(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeBaselineShift(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeRxOrRy(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeCursor(CSSParserTokenRange&, const CSSParserContext&, bool inQuirksMode);
 RefPtr<CSSValue> consumeAttr(CSSParserTokenRange args, const CSSParserContext&);
 RefPtr<CSSValue> consumeCounterContent(CSSParserTokenRange args, bool counters);
@@ -387,11 +278,7 @@ RefPtr<CSSValue> consumeContent(CSSParserTokenRange&, const CSSParserContext&);
 RefPtr<CSSValue> consumePerspective(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeScrollSnapAlign(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeScrollSnapType(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeOverscrollBehavior(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeBorderRadiusCorner(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeTextUnderlineOffset(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeTextDecorationThickness(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeVerticalAlign(CSSParserTokenRange&, CSSParserMode);
 bool consumeRadii(RefPtr<CSSPrimitiveValue> horizontalRadii[4], RefPtr<CSSPrimitiveValue> verticalRadii[4], CSSParserTokenRange&, CSSParserMode, bool useLegacyParsing);
 enum class ConsumeRay { Include, Exclude };
 RefPtr<CSSValue> consumePathOperation(CSSParserTokenRange&, const CSSParserContext&, ConsumeRay);
@@ -433,14 +320,10 @@ RefPtr<CSSValue> consumeGridTrackList(CSSParserTokenRange&, const CSSParserConte
 RefPtr<CSSValue> consumeGridTemplatesRowsOrColumns(CSSParserTokenRange&, const CSSParserContext&);
 RefPtr<CSSValue> consumeGridTemplateAreas(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeLineBoxContain(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeWebkitLineGrid(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeContainerName(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeWebkitInitialLetter(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeSpeakAs(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeHangingPunctuation(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeWebkitMarqueeIncrement(CSSParserTokenRange&, CSSParserMode);
-RefPtr<CSSValue> consumeWebkitMarqueeRepetition(CSSParserTokenRange&);
-RefPtr<CSSValue> consumeWebkitMarqueeSpeed(CSSParserTokenRange&, CSSParserMode);
 RefPtr<CSSValue> consumeAlt(CSSParserTokenRange&, const CSSParserContext&);
 RefPtr<CSSValue> consumeContain(CSSParserTokenRange&);
 RefPtr<CSSValue> consumeContainIntrinsicSize(CSSParserTokenRange&);
@@ -448,9 +331,88 @@ RefPtr<CSSValue> consumeTextEmphasisPosition(CSSParserTokenRange&);
 #if ENABLE(DARK_MODE_CSS)
 RefPtr<CSSValue> consumeColorScheme(CSSParserTokenRange&);
 #endif
-RefPtr<CSSValue> consumeListStyleType(CSSParserTokenRange&, const CSSParserContext&);
 RefPtr<CSSValue> consumeOffsetRotate(CSSParserTokenRange&, CSSParserMode);
 
+
+// Template and inline implementations are at the bottom of the file for readability.
+
+template<typename... emptyBaseCase> bool identMatches(CSSValueID)
+{
+    return false;
+}
+
+template<CSSValueID head, CSSValueID... tail> bool identMatches(CSSValueID id)
+{
+    return id == head || identMatches<tail...>(id);
+}
+
+template<CSSValueID... names> std::optional<CSSValueID> consumeIdentRaw(CSSParserTokenRange& range)
+{
+    if (range.peek().type() != IdentToken || !identMatches<names...>(range.peek().id()))
+        return std::nullopt;
+    return range.consumeIncludingWhitespace().id();
+}
+
+template<CSSValueID... names> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range)
+{
+    return consumeIdentWorkerSafe<names...>(range, CSSValuePool::singleton());
+}
+
+template<CSSValueID... names> RefPtr<CSSPrimitiveValue> consumeIdentWorkerSafe(CSSParserTokenRange& range, CSSValuePool& cssValuePool)
+{
+    if (range.peek().type() != IdentToken || !identMatches<names...>(range.peek().id()))
+        return nullptr;
+    return cssValuePool.createIdentifierValue(range.consumeIncludingWhitespace().id());
+}
+
+template<typename Predicate, typename... Args> std::optional<CSSValueID> consumeIdentRaw(CSSParserTokenRange& range, Predicate&& predicate, Args&&... args)
+{
+    if (auto keyword = range.peek().id(); predicate(keyword, std::forward<Args>(args)...)) {
+        range.consumeIncludingWhitespace();
+        return keyword;
+    }
+    return std::nullopt;
+}
+
+template<typename Predicate, typename... Args> RefPtr<CSSPrimitiveValue> consumeIdent(CSSParserTokenRange& range, Predicate&& predicate, Args&&... args)
+{
+    return consumeIdentWorkerSafe(range, CSSValuePool::singleton(), std::forward<Predicate>(predicate), std::forward<Args>(args)...);
+}
+
+template<typename Predicate, typename... Args> RefPtr<CSSPrimitiveValue> consumeIdentWorkerSafe(CSSParserTokenRange& range, CSSValuePool& cssValuePool, Predicate&& predicate, Args&&... args)
+{
+    if (auto keyword = range.peek().id(); predicate(keyword, std::forward<Args>(args)...)) {
+        range.consumeIncludingWhitespace();
+        return cssValuePool.createIdentifierValue(keyword);
+    }
+    return nullptr;
+}
+
+inline bool isFontStyleAngleInRange(double angleInDegrees)
+{
+    return angleInDegrees >= -90 && angleInDegrees <= 90;
+}
+
+inline bool isSystemFontShorthand(CSSValueID valueID)
+{
+    // This needs to stay in sync with SystemFontDatabase::FontShorthand.
+    static_assert(CSSValueStatusBar - CSSValueCaption == static_cast<SystemFontDatabase::FontShorthandUnderlyingType>(SystemFontDatabase::FontShorthand::StatusBar));
+    return valueID >= CSSValueCaption && valueID <= CSSValueStatusBar;
+}
+
+inline SystemFontDatabase::FontShorthand lowerFontShorthand(CSSValueID valueID)
+{
+    // This needs to stay in sync with SystemFontDatabase::FontShorthand.
+    ASSERT(isSystemFontShorthand(valueID));
+    return static_cast<SystemFontDatabase::FontShorthand>(valueID - CSSValueCaption);
+}
+
+template<typename... Args>
+Ref<CSSPrimitiveValue> createPrimitiveValuePair(Args&&... args)
+{
+    return CSSValuePool::singleton().createValue(Pair::create(std::forward<Args>(args)...));
+}
+
 } // namespace CSSPropertyParserHelpers
 
 } // namespace WebCore
diff --git a/Source/WebCore/css/parser/CSSPropertyParserWorkerSafe.cpp b/Source/WebCore/css/parser/CSSPropertyParserWorkerSafe.cpp
index 4ff921d8ae1f..99cf41efeb9c 100644
--- a/Source/WebCore/css/parser/CSSPropertyParserWorkerSafe.cpp
+++ b/Source/WebCore/css/parser/CSSPropertyParserWorkerSafe.cpp
@@ -546,7 +546,7 @@ static RefPtr<CSSFontFeatureValue> consumeFontFeatureTag(CSSParserTokenRange& ra
     int tagValue = 1;
     if (!range.atEnd() && range.peek().type() != CommaToken) {
         // Feature tag values could follow: <integer> | on | off
-        if (auto integer = CSSPropertyParserHelpers::consumeIntegerZeroAndGreaterRaw(range))
+        if (auto integer = CSSPropertyParserHelpers::consumeNonNegativeIntegerRaw(range))
             tagValue = *integer;
         else if (range.peek().id() == CSSValueOn || range.peek().id() == CSSValueOff)
             tagValue = range.consumeIncludingWhitespace().id() == CSSValueOn;
diff --git a/Source/WebCore/css/process-css-properties.py b/Source/WebCore/css/process-css-properties.py
index 7efa650723ff..0d8c7a2477bc 100755
--- a/Source/WebCore/css/process-css-properties.py
+++ b/Source/WebCore/css/process-css-properties.py
@@ -43,34 +43,27 @@ def count_iterable(iterable):
     return sum(1 for _ in iterable)
 
 
-class ParsingContext:
-    def __init__(self, *, defines_string, parsing_for_codegen, verbose):
-        if defines_string:
-            self.conditionals = frozenset(defines_string.split(' '))
-        else:
-            self.conditionals = frozenset()
-        self.parsing_for_codegen = parsing_for_codegen
-        self.verbose = verbose
+def compact(iterable):
+    return filter(lambda value: value is not None, iterable)
 
-    def is_enabled(self, *, conditional):
-        if conditional[0] == '!':
-            return conditional[1:] not in self.conditionals
-        return conditional in self.conditionals
 
-    def select_enabled_variant(self, variants, *, label):
-        for variant in variants:
-            if "enable-if" not in variant:
-                raise Exception(f"Invalid conditional definition for '{label}'. No 'enable-if' property found.")
+def compact_map(function, iterable):
+    return compact(map(function, iterable))
 
-            if self.is_enabled(conditional=variant["enable-if"]):
-                return variant
 
-        raise Exception(f"Invalid conditional definition for '{label}'. No 'enable-if' property matched the active set.")
+def flatten(list_to_flatten):
+    flattened_list = []
+    for element in list_to_flatten:
+        if type(element) is list:
+            flattened_list += element
+        else:
+            flattened_list += [element]
+    return flattened_list
 
 
 class Schema:
     class Entry:
-        def __init__(self, key, *, allowed_types, default_value=None, required=False):
+        def __init__(self, key, *, allowed_types, default_value=None, required=False, convert_to=None):
             if default_value and required:
                 raise Exception(f"Invalid Schema.Entry for '{key}'. Cannot specify both 'default_value' and 'required'.")
 
@@ -78,38 +71,52 @@ def __init__(self, key, *, allowed_types, default_value=None, required=False):
             self.allowed_types = allowed_types
             self.default_value = default_value
             self.required = required
+            self.convert_to = convert_to
 
     def __init__(self, *entries):
         self.entries = {entry.key: entry for entry in entries}
 
+    def __add__(self, other):
+        return Schema(*list({**self.entries, **other.entries}.values()))
+
     def set_attributes_from_dictionary(self, dictionary, *, instance):
         for entry in self.entries.values():
             setattr(instance, entry.key.replace("-", "_"), dictionary.get(entry.key, entry.default_value))
 
-    def validate_keys(self, dictionary, *, label):
+    def validate_keys(self, parsing_context, key_path, dictionary, *, label):
         invalid_keys = list(filter(lambda key: key not in self.entries.keys(), dictionary.keys()))
         if len(invalid_keys) == 1:
-            raise Exception(f"Invalid key for '{label}': {invalid_keys[0]}")
+            raise Exception(f"Invalid key for '{label} - {key_path}': {invalid_keys[0]}")
         if len(invalid_keys) > 1:
-            raise Exception(f"Invalid keys for '{label}': {invalid_keys}")
+            raise Exception(f"Invalid keys for '{label} - {key_path}': {invalid_keys}")
 
-    def validate_types(self, dictionary, *, label):
+    def validate_types(self, parsing_context, key_path, dictionary, *, label):
         for key, value in dictionary.items():
             if type(value) not in self.entries[key].allowed_types:
-                raise Exception(f"Invalid type '{type(value)}' for key '{key}' in '{label}'. Expected type in set '{self.entries[key].allowed_types}'.")
+                raise Exception(f"Invalid type '{type(value)}' for key '{key}' in '{label} - {key_path}'. Expected type in set '{self.entries[key].allowed_types}'.")
 
-    def validate_requirements(self, dictionary, *, label):
+    def validate_requirements(self, parsing_context, key_path, dictionary, *, label):
         for key, entry in self.entries.items():
             if entry.required and key not in dictionary:
-                raise Exception(f"Required key '{key}' not found in '{label}'.")
+                raise Exception(f"Required key '{key}' not found in '{label} - {key_path}'.")
+
+    def apply_conversions(self, parsing_context, key_path, dictionary, *, label):
+        for key, entry in self.entries.items():
+            if entry.convert_to and key in dictionary:
+                dictionary[key] = entry.convert_to.from_json(parsing_context, key_path, dictionary[key])
 
-    def validate_dictionary(self, dictionary, *, label):
-        self.validate_keys(dictionary, label=label)
-        self.validate_types(dictionary, label=label)
-        self.validate_requirements(dictionary, label=label)
+    def validate_dictionary(self, parsing_context, key_path, dictionary, *, label):
+        self.validate_keys(parsing_context, key_path, dictionary, label=label)
+        self.validate_types(parsing_context, key_path, dictionary, label=label)
+        self.validate_requirements(parsing_context, key_path, dictionary, label=label)
+        self.apply_conversions(parsing_context, key_path, dictionary, label=label)
 
 
 class Name(object):
+    special_case_name_to_id = {
+        "url": "URL",
+    }
+
     def __init__(self, name):
         self.name = name
         self.id_without_prefix = Name.convert_name_to_id(self.name)
@@ -122,7 +129,7 @@ def __repr__(self):
 
     @staticmethod
     def convert_name_to_id(name):
-        return re.sub(r'(^[^-])|-(.)', lambda m: (m[1] or m[2]).upper(), name)
+        return Name.special_case_name_to_id.get(name) or re.sub(r'(^[^-])|-(.)', lambda m: (m[1] or m[2]).upper(), name)
 
     @property
     def id_without_prefix_with_lowercase_first_letter(self):
@@ -165,6 +172,10 @@ def __str__(self):
     def __repr__(self):
         return self.__str__()
 
+    def from_json(parsing_context, key_path, json_value):
+        assert(type(json_value) is str)
+        return ValueKeywordName(json_value)
+
     @property
     def id_without_scope(self):
         return f"CSSValue{self.id_without_prefix}"
@@ -196,7 +207,7 @@ def from_json(parsing_context, key_path, json_value):
             return Status(status=json_value)
 
         assert(type(json_value) is dict)
-        Status.schema.validate_dictionary(json_value, label=f"Status ({key_path}.status)")
+        Status.schema.validate_dictionary(parsing_context, f"{key_path}.status", json_value, label=f"Status")
 
         return Status(**json_value)
 
@@ -226,7 +237,7 @@ def __repr__(self):
     @staticmethod
     def from_json(parsing_context, key_path, json_value):
         assert(type(json_value) is dict)
-        Specification.schema.validate_dictionary(json_value, label=f"Specification ({key_path}.specification)")
+        Specification.schema.validate_dictionary(parsing_context, f"{key_path}.specification", json_value, label=f"Specification")
         return Specification(**json_value)
 
 
@@ -243,6 +254,17 @@ class Value:
     def __init__(self, **dictionary):
         Value.schema.set_attributes_from_dictionary(dictionary, instance=self)
         self.value_keyword_name = ValueKeywordName(self.value)
+        self.keyword_term = self._build_keyword_term()
+
+    def _build_keyword_term(self):
+        dictionary = {"kind": "keyword", "value": self.value_keyword_name}
+        if self.comment:
+            dictionary["comment"] = self.comment
+        if self.settings_flag:
+            dictionary["settings-flag"] = self.settings_flag
+        if self.status:
+            dictionary["status"] = self.status
+        return KeywordTerm(**dictionary)
 
     def __str__(self):
         return f"Value {vars(self)}"
@@ -262,7 +284,7 @@ def from_json(parsing_context, key_path, json_value):
             return Value.from_json(parsing_context, key_path, {"value": json_value})
 
         assert(type(json_value) is dict)
-        Value.schema.validate_dictionary(json_value, label=f"Value ({key_path}.values)")
+        Value.schema.validate_dictionary(parsing_context, f"{key_path}.values", json_value, label=f"Value")
 
         if "enable-if" in json_value and not parsing_context.is_enabled(conditional=json_value["enable-if"]):
             if parsing_context.verbose:
@@ -349,7 +371,7 @@ def _update_kind_and_logic(self):
     @staticmethod
     def from_json(parsing_context, key_path, json_value):
         assert(type(json_value) is dict)
-        LogicalPropertyGroup.schema.validate_dictionary(json_value, label=f"LogicalPropertyGroup ({key_path}.logical-property-group)")
+        LogicalPropertyGroup.schema.validate_dictionary(parsing_context, f"{key_path}.logical-property-group", json_value, label=f"LogicalPropertyGroup")
         return LogicalPropertyGroup(**json_value)
 
 
@@ -371,10 +393,10 @@ def __repr__(self):
     @staticmethod
     def from_json(parsing_context, key_path, json_value):
         if type(json_value) is str:
-            return Value(value=json_value)
+            return Longhand.from_json(parsing_context, key_path, {"value": json_value})
 
         assert(type(json_value) is dict)
-        Longhand.schema.validate_dictionary(json_value, label=f"Longhand ({key_path}.longhands)")
+        Longhand.schema.validate_dictionary(parsing_context, f"{key_path}.longhands", json_value, label=f"Longhand")
 
         if "enable-if" in json_value and not parsing_context.is_enabled(conditional=json_value["enable-if"]):
             if parsing_context.verbose:
@@ -408,6 +430,9 @@ class CodeGenProperties:
         Schema.Entry("longhands", allowed_types=[list]),
         Schema.Entry("name-for-methods", allowed_types=[str]),
         Schema.Entry("parser-function", allowed_types=[str]),
+        Schema.Entry("parser-exported", allowed_types=[bool]),
+        Schema.Entry("parser-grammar", allowed_types=[list, dict, str]),
+        Schema.Entry("parser-grammar-comment", allowed_types=[str]),
         Schema.Entry("parser-requires-additional-parameters", allowed_types=[list], default_value=[]),
         Schema.Entry("parser-requires-context", allowed_types=[bool], default_value=False),
         Schema.Entry("parser-requires-context-mode", allowed_types=[bool], default_value=False),
@@ -415,7 +440,6 @@ class CodeGenProperties:
         Schema.Entry("parser-requires-current-property", allowed_types=[bool], default_value=False),
         Schema.Entry("parser-requires-quirks-mode", allowed_types=[bool], default_value=False),
         Schema.Entry("parser-requires-value-pool", allowed_types=[bool], default_value=False),
-        Schema.Entry("partial-keyword-property", allowed_types=[bool], default_value=False),
         Schema.Entry("related-property", allowed_types=[str]),
         Schema.Entry("separator", allowed_types=[str]),
         Schema.Entry("setter", allowed_types=[str]),
@@ -448,7 +472,7 @@ def from_json(parsing_context, key_path, name, json_value):
             json_value = parsing_context.select_enabled_variant(json_value, label=f"{key_path}.codegen-properties")
 
         assert(type(json_value) is dict)
-        CodeGenProperties.schema.validate_dictionary(json_value, label=f"CodeGenProperties ({key_path}.codegen-properties)")
+        CodeGenProperties.schema.validate_dictionary(parsing_context, f"{key_path}.codegen-properties", json_value, label=f"CodeGenProperties")
 
         property_name = PropertyName(name, name_for_methods=json_value.get("name-for-methods"))
 
@@ -476,7 +500,7 @@ def from_json(parsing_context, key_path, name, json_value):
             json_value["logical-property-group"] = LogicalPropertyGroup.from_json(parsing_context, f"{key_path}.codegen-properties", json_value["logical-property-group"])
 
         if "longhands" in json_value:
-            json_value["longhands"] = list(filter(lambda value: value is not None, map(lambda value: Longhand.from_json(parsing_context, f"{key_path}.codegen-properties", value), json_value["longhands"])))
+            json_value["longhands"] = list(compact_map(lambda value: Longhand.from_json(parsing_context, f"{key_path}.codegen-properties", value), json_value["longhands"]))
             if not json_value["longhands"]:
                 longhands = None
 
@@ -514,6 +538,11 @@ def from_json(parsing_context, key_path, name, json_value):
             if json_value.get("high-priority", False):
                 raise Exception(f"{key_path} can't have both a related property and be high priority.")
 
+        if json_value.get("parser-grammar"):
+            grammar = Grammar.from_json(parsing_context, f"{key_path}", name, json_value["parser-grammar"])
+            grammar.perform_fixups(parsing_context.parsed_shared_grammar_rules)
+            json_value["parser-grammar"] = grammar
+
         return CodeGenProperties(property_name, **json_value)
 
     @property
@@ -538,8 +567,8 @@ class Property:
         Schema.Entry("animatable", allowed_types=[bool], default_value=False),
         Schema.Entry("codegen-properties", allowed_types=[dict, list]),
         Schema.Entry("inherited", allowed_types=[bool], default_value=False),
-        Schema.Entry("specification", allowed_types=[dict]),
-        Schema.Entry("status", allowed_types=[dict, str]),
+        Schema.Entry("specification", allowed_types=[dict], convert_to=Specification),
+        Schema.Entry("status", allowed_types=[dict, str], convert_to=Status),
         Schema.Entry("values", allowed_types=[list]),
     )
 
@@ -547,8 +576,7 @@ def __init__(self, **dictionary):
         Property.schema.set_attributes_from_dictionary(dictionary, instance=self)
         self.property_name = self.codegen_properties.property_name
         self.synonymous_properties = []
-        self._values_sorted_by_name = None
-
+        self._fast_path_keyword_terms_sorted_by_name = None
 
     def __str__(self):
         return self.name
@@ -559,28 +587,26 @@ def __repr__(self):
     @staticmethod
     def from_json(parsing_context, key_path, name, json_value):
         assert(type(json_value) is dict)
-        Property.schema.validate_dictionary(json_value, label=f"Property ({key_path}.{name})")
+        Property.schema.validate_dictionary(parsing_context, f"{key_path}.{name}", json_value, label=f"Property")
 
         codegen_properties = CodeGenProperties.from_json(parsing_context, f"{key_path}.{name}", name, json_value.get("codegen-properties", {}))
         json_value["codegen-properties"] = codegen_properties
 
+        if codegen_properties.enable_if is not None and not parsing_context.is_enabled(conditional=codegen_properties.enable_if):
+            if parsing_context.verbose:
+                print(f"SKIPPED {name} due to failing to satisfy 'enable-if' condition, '{json_value['codegen-properties'].enable_if}', with active macro set")
+            return None
+
+        if codegen_properties.skip_codegen is not None and codegen_properties.skip_codegen:
+            if parsing_context.verbose:
+                print(f"SKIPPED {name} due to 'skip-codegen'")
+            return None
+
         if "values" in json_value:
-            json_value["values"] = list(filter(lambda value: value is not None, map(lambda value: Value.from_json(parsing_context, f"{key_path}.{name}", value), json_value["values"])))
-        if "status" in json_value:
-            json_value["status"] = Status.from_json(parsing_context, f"{key_path}.{name}", json_value["status"])
-        if "specification" in json_value:
-            json_value["specification"] = Specification.from_json(parsing_context, f"{key_path}.{name}", json_value["specification"])
-
-        if parsing_context.parsing_for_codegen:
-            if "codegen-properties" in json_value:
-                if json_value["codegen-properties"].enable_if is not None and not parsing_context.is_enabled(conditional=json_value["codegen-properties"].enable_if):
-                    if parsing_context.verbose:
-                        print(f"SKIPPED {name} due to failing to satisfy 'enable-if' condition, '{json_value['codegen-properties'].enable_if}', with active macro set")
-                    return None
-                if json_value["codegen-properties"].skip_codegen is not None and json_value["codegen-properties"].skip_codegen:
-                    if parsing_context.verbose:
-                        print(f"SKIPPED {name} due to 'skip-codegen'")
-                    return None
+            values = list(filter(lambda value: value is not None, map(lambda value: Value.from_json(parsing_context, f"{key_path}.{name}", value), json_value["values"])))
+            if codegen_properties.parser_grammar:
+                codegen_properties.parser_grammar.perform_fixups_for_values_references(values)
+            json_value["values"] = values
 
         return Property(**json_value)
 
@@ -691,37 +717,48 @@ def is_skipped_from_computed_style(self):
         return False
 
     @property
-    def values_sorted_by_name(self):
-        if not self._values_sorted_by_name:
-            self._values_sorted_by_name = sorted(self.values, key=functools.cmp_to_key(Properties._sort_with_prefixed_properties_last))
-        return self._values_sorted_by_name
+    def is_eligible_for_fast_path(self):
+        if self.codegen_properties.longhands or self.codegen_properties.descriptor_only or self.codegen_properties.skip_parser:
+            return False
+        return True
 
     @property
-    def values_without_settings_flag(self):
-        return (value for value in self.values_sorted_by_name if not value.settings_flag)
+    def _fast_path_keyword_terms(self):
+        if not self.is_eligible_for_fast_path:
+            return []
+        if self.codegen_properties.parser_grammar:
+            return self.codegen_properties.parser_grammar.fast_path_keyword_terms
+        return (value.keyword_term for value in self.values if value.keyword_term.is_eligible_for_fast_path)
 
     @property
-    def values_with_settings_flag(self):
-        return (value for value in self.values_sorted_by_name if value.settings_flag)
+    def fast_path_keyword_terms_sorted_by_name(self):
+        if not self.is_eligible_for_fast_path:
+            return []
+        if not self._fast_path_keyword_terms_sorted_by_name:
+            self._fast_path_keyword_terms_sorted_by_name = sorted(self._fast_path_keyword_terms, key=functools.cmp_to_key(Properties._sort_with_prefixed_properties_last))
+        return self._fast_path_keyword_terms_sorted_by_name
 
     @property
-    def a_value_requires_a_settings_flag_or_is_internal(self):
-        for value in self.values:
-            if value.settings_flag or value.status == "internal":
-                return True
-        return False
+    def has_only_keyword_terms(self):
+        if self.codegen_properties.parser_grammar:
+            return self.codegen_properties.parser_grammar.has_only_keyword_terms
+        return self.values is not None
 
     @property
-    def accepts_a_single_value_keyword(self):
-        if self.codegen_properties.longhands:
+    def has_fast_path_keyword_terms(self):
+        if not self.is_eligible_for_fast_path:
             return False
-        if self.codegen_properties.descriptor_only:
-            return False
-        if not self.values:
-            return False
-        if (self.codegen_properties.custom_parser or self.codegen_properties.parser_function) and not self.codegen_properties.partial_keyword_property:
+        if self.codegen_properties.parser_grammar:
+            return self.codegen_properties.parser_grammar.has_fast_path_keyword_terms
+        return self.values and any(value.keyword_term.is_eligible_for_fast_path for value in self.values)
+
+    @property
+    def has_only_fast_path_keyword_terms(self):
+        if not self.is_eligible_for_fast_path:
             return False
-        return True
+        if self.codegen_properties.parser_grammar:
+            return self.codegen_properties.parser_grammar.has_only_fast_path_keyword_terms
+        return self.values and all(value.keyword_term.is_eligible_for_fast_path for value in self.values)
 
     # Specialized properties to compute method names.
 
@@ -767,12 +804,6 @@ def enum_name_for_layers_type(self):
 
 
 class Properties:
-    schema = Schema(
-        Schema.Entry("categories", allowed_types=[dict], required=True),
-        Schema.Entry("instructions", allowed_types=[list], required=True),
-        Schema.Entry("properties", allowed_types=[dict], required=True),
-    )
-
     def __init__(self, *properties):
         self.properties = properties
         self.properties_by_name = {property.name: property for property in properties}
@@ -781,35 +812,19 @@ def __init__(self, *properties):
         self._all_computed = None
         self._settings_flags = None
 
+        self._perform_fixups()
+
     def __str__(self):
         return "Properties"
 
     def __repr__(self):
         return self.__str__()
 
-    @staticmethod
-    def from_json(parsing_context, top_level_object):
-        Properties.schema.validate_dictionary(top_level_object, label="top level object")
-
-        properties = Properties(
-            *list(
-                filter(
-                    lambda value: value is not None,
-                    map(
-                        lambda item: Property.from_json(parsing_context, "$properties", item[0], item[1]),
-                        top_level_object["properties"].items()
-                    )
-                )
-            )
-        )
-
-        # Now that all the properties have been parsed, go back through them and replace
-        # any references to other properties that were by name (e.g. string) with a direct
-        # reference to the property object.
-        for property in properties.properties:
-            property.perform_fixups(properties)
-
-        return properties
+    # Updates any references to other properties that were by name (e.g. string) with a direct
+    # reference to the property object.
+    def _perform_fixups(self):
+        for property in self.properties:
+            property.perform_fixups(self)
 
     # Returns the set of all properties. Default decreasing priority and name sorting.
     @property
@@ -852,8 +867,8 @@ def all_non_shorthands(self):
 
     # Returns a generator for the set of properties that can accept a single value keyword. Default decreasing priority and name sorting.
     @property
-    def all_accepting_a_single_value_keyword(self):
-        return (property for property in self.all if property.accepts_a_single_value_keyword)
+    def all_with_fast_path_keyword_terms(self):
+        return (property for property in self.all if property.has_fast_path_keyword_terms)
 
     # Returns a generator for the set of properties that are direction-aware (aka flow-sensative). Sorted first by property group name and then by property name.
     @property
@@ -938,202 +953,801 @@ def _sort_with_prefixed_properties_last(a, b):
         return 0
 
 
-# GENERATION
+# MARK: - Property Parsing
 
-class GenerationContext:
-    def __init__(self, properties, *, verbose, gperf_executable):
-        self.properties = properties
-        self.verbose = verbose
-        self.gperf_executable = gperf_executable
+class Term:
+    schema = Schema(
+        Schema.Entry("comment", allowed_types=[str]),
+        Schema.Entry("enable-if", allowed_types=[str]),
+        Schema.Entry("kind", allowed_types=[str], required=True),
+        Schema.Entry("status", allowed_types=[str]),
+    )
 
-    # Shared generation constants.
+    @staticmethod
+    def from_json(parsing_context, key_path, json_value):
+        if type(json_value) is str:
+            if ReferenceTerm.is_reference_string(json_value):
+                return ReferenceTerm.from_json(parsing_context, key_path, {"kind": "reference", "value": json_value})
+            else:
+                return KeywordTerm.from_json(parsing_context, key_path, {"kind": "keyword", "value": json_value})
 
-    number_of_predefined_properties = 2
+        if type(json_value) is list:
+            return MatchOneTerm.from_json(parsing_context, key_path, {"kind": "match-one", "value": json_value})
 
-    # Runs `gperf` on the output of the generated file CSSPropertyNames.gperf
+        assert(type(json_value) is dict)
+        if "value" not in json_value:
+            raise Exception(f"Invalid Term found at {key_path}. All terms must have a 'value' specified.")
+
+        if "kind" not in json_value:
+            # As a shorthand, allow 'keyword' and 'reference' terms to skip specifying a kind, as it is umambiguous
+            # what kind they are.
+            if type(json_value["value"] is str):
+                if ReferenceTerm.is_reference_string(json_value["value"]):
+                    return ReferenceTerm.from_json(parsing_context, key_path, {"kind": "reference", **json_value})
+                else:
+                    return KeywordTerm.from_json(parsing_context, key_path, {"kind": "keyword", **json_value})
 
-    def run_gperf(self):
-        gperf_command = self.gperf_executable or os.environ['GPERF']
+            raise Exception(f"Invalid Term found at {key_path}. All terms with non-string values must have a 'kind' specified.")
 
-        gperf_result_code = subprocess.call([gperf_command, '--key-positions=*', '-D', '-n', '-s', '2', 'CSSPropertyNames.gperf', '--output-file=CSSPropertyNames.cpp'])
-        if gperf_result_code != 0:
-            raise Exception(f"Error when generating CSSPropertyNames.cpp from CSSPropertyNames.gperf: {gperf_result_code}")
+        kind = json_value["kind"]
+        if kind == "match-one":
+            return MatchOneTerm.from_json(parsing_context, key_path, json_value)
+        elif kind == "reference":
+            return ReferenceTerm.from_json(parsing_context, key_path, json_value)
+        elif kind == "keyword":
+            return KeywordTerm.from_json(parsing_context, key_path, json_value)
+        else:
+            raise Exception(f"Invalid Term found at {key_path}. Unknown 'kind' specified: '{kind}'.")
 
-    # Shared generator templates.
 
-    def _generate_property_id_switch_function(self, *, to, signature, properties, mapping, default, prologue=None, epilogue=None):
-        to.write(f"{signature}\n")
-        to.write(f"{{\n")
+class BuiltinSchema:
+    class OptionalParameter:
+        def __init__(self, name, values, default):
+            self.name = name
+            self.values = values
+            self.default = default
 
-        if prologue:
-            to.write(textwrap.indent(prologue, '    ') + "\n")
+    class RequiredParameter:
+        def __init__(self, name, values):
+            self.name = name
+            self.values = values
 
-        to.write(f"    switch (id) {{\n")
+    class Entry:
+        def __init__(self, name, consume_function_name, *parameter_descriptors):
+            self.name = Name(name)
+            self.consume_function_name = consume_function_name
+
+            # Mapping of descriptor name (e.g. 'value_range' or 'mode') to OptionalParameter descriptor.
+            self.optionals = {}
+
+            # Mapping of descriptor name (e.g. 'value_range' or 'mode') to RequiredParameter descriptor.
+            self.requireds = {}
+
+            # Mapping from all the potential values (e.g. 'svg', 'unitless-allowed') to the parameter descriptor (e.g. OptionalParameter/RequiredParameter instances).
+            self.value_to_descriptor = {}
+
+            for parameter_descriptor in parameter_descriptors:
+                if isinstance(parameter_descriptor, BuiltinSchema.OptionalParameter):
+                    self.optionals[parameter_descriptor.name] = parameter_descriptor
+                    for value in parameter_descriptor.values.keys():
+                        self.value_to_descriptor[value] = parameter_descriptor
+                if isinstance(parameter_descriptor, BuiltinSchema.RequiredParameter):
+                    self.requireds[parameter_descriptor.name] = parameter_descriptor
+                    for value in parameter_descriptor.values.keys():
+                        self.value_to_descriptor[value] = parameter_descriptor
+
+            def builtin_schema_type_init(self, parameters):
+                # Map from descriptor name (e.g. 'value_range' or 'mode') to mapped value (e.g. `ValueRange::NonNegative` or `HTMLStandardMode`) for all of the parameters.
+                self.parameter_map = {}
+
+                # Map from descriptor name (e.g. 'value_range' or 'mode') to parameter value (e.g. `[0,inf]` or `strict`) for all of the parameters.
+                descriptors_used = {}
+
+                # Example parameters is ['svg', 'unitless-allowed'].
+                for parameter in parameters:
+                    if parameter not in self.entry.value_to_descriptor:
+                        raise Exception(f"Unknown parameter '{parameter}' passed to <{self.entry.name.name}>. Supported parameters are {', '.join(quote_iterable(self.entry.value_to_descriptor.keys()))}.")
+
+                    descriptor = self.entry.value_to_descriptor[parameter]
+                    if descriptor.name in descriptors_used:
+                        raise Exception(f"More than one parameter of type '{descriptor.name}` passed to <{self.entry.name.name}>, pick one: {descriptors_used[descriptor.name]}, {parameter}.")
+                    descriptors_used[descriptor.name] = parameter
+
+                    self.parameter_map[descriptor.name] = descriptor.values[parameter]
+
+                # Fill `results` with mappings from `names` (e.g. `value_range`) to mapped to value (e.g. `ValueRange::NonNegative`)
+                self.results = {}
+                for descriptor in self.entry.optionals.values():
+                    self.results[descriptor.name] = self.parameter_map.get(descriptor.name, descriptor.default)
+                for descriptor in self.entry.requireds.values():
+                    if descriptor.name not in self.parameter_map:
+                        raise Exception(f"Required parameter of type '{descriptor.name}` not passed to <{self.entry.name.name}>. Pick one of {', '.join(quote_iterable(descriptor.values.keys()))}.")
+                    self.results[descriptor.name] = self.parameter_map.get(descriptor.name)
+
+            def builtin_schema_type_parameter_string_getter(name, self):
+                return self.results[name]
+
+            # Dynamically generate a class that can handle validationg and generation.
+            class_name = f"Builtin{self.name.id_without_prefix}Consumer"
+            class_attributes = {
+                "__init__": builtin_schema_type_init,
+                "consume_function_name": self.consume_function_name,
+                "entry": self,
+            }
 
-        for property in properties:
-            to.write(f"    case {property.id}:\n")
-            to.write(f"        {mapping(property)}\n")
+            for name in itertools.chain(self.optionals.keys(), self.requireds.keys()):
+                class_attributes[name.replace('-', '_')] = property(functools.partial(builtin_schema_type_parameter_string_getter, name))
 
-        to.write(f"    default:\n")
-        to.write(f"        {default}\n")
-        to.write(f"    }}\n")
+            self.constructor = type(class_name, (), class_attributes)
 
-        if epilogue:
-            to.write(textwrap.indent(epilogue, '    ') + "\n")
+            # Also add the type to the global scope for use in other classes.
+            globals()[class_name] = self.constructor
 
-        to.write(f"}}\n\n")
+    def __init__(self, *entries):
+        self.entries = {entry.name.name: entry for entry in entries}
 
-    def _generate_property_id_switch_function_bool(self, *, to, signature, properties):
-        to.write(f"{signature}\n")
-        to.write(f"{{\n")
-        to.write(f"    switch (id) {{\n")
+    def validate_and_construct_if_builtin(self, name, parameters):
+        if name.name in self.entries:
+            return self.entries[name.name].constructor(parameters)
+        return None
 
-        for property in properties:
-            to.write(f"    case {property.id}:\n")
 
-        to.write(f"        return true;\n")
-        to.write(f"    default:\n")
-        to.write(f"        return false;\n")
-        to.write(f"    }}\n")
-        to.write(f"}}\n\n")
+# Reference terms look like keyword terms, but are surrounded by '<' and '>' characters (i.e. "<number>").
+# They can either reference a rule from the grammer-rules set, in which case they will be replaced by
+# the real term during fixup, or a builtin rule, in which case they will inform the generator to call
+# out to a handwritten consumer.
+#
+#   { "kind": "reference", "value": "<length unitless-allowed>" }
+#
+# or using shorthand
+#
+#   "<length unitless-allowed>"
+#
+class ReferenceTerm:
+    schema = Term.schema + Schema(
+        Schema.Entry("value", allowed_types=[str], required=True),
+    )
 
-    # MARK: - Helper generator functions for CSSPropertyNames.h
+    builtins = BuiltinSchema(
+        BuiltinSchema.Entry("angle", "consumeAngle",
+            BuiltinSchema.OptionalParameter("mode", values={"svg": "SVGAttributeMode", "strict": "HTMLStandardMode"}, default=None),
+            BuiltinSchema.OptionalParameter("unitless", values={"unitless-allowed": "UnitlessQuirk::Allow"}, default="UnitlessQuirk::Forbid"),
+            BuiltinSchema.OptionalParameter("unitless-zero", values={"unitless-zero-allowed": "UnitlessZeroQuirk::Allow"}, default="UnitlessZeroQuirk::Forbid")),
+        BuiltinSchema.Entry("length", "consumeLength",
+            BuiltinSchema.OptionalParameter("value_range", values={"[0,inf]": "ValueRange::NonNegative"}, default="ValueRange::All"),
+            BuiltinSchema.OptionalParameter("mode", values={"svg": "SVGAttributeMode", "strict": "HTMLStandardMode"}, default=None),
+            BuiltinSchema.OptionalParameter("unitless", values={"unitless-allowed": "UnitlessQuirk::Allow"}, default="UnitlessQuirk::Forbid")),
+        BuiltinSchema.Entry("length-percentage", "consumeLengthOrPercent",
+            BuiltinSchema.OptionalParameter("value_range", values={"[0,inf]": "ValueRange::NonNegative"}, default="ValueRange::All"),
+            BuiltinSchema.OptionalParameter("mode", values={"svg": "SVGAttributeMode", "strict": "HTMLStandardMode"}, default=None),
+            BuiltinSchema.OptionalParameter("unitless", values={"unitless-allowed": "UnitlessQuirk::Allow"}, default="UnitlessQuirk::Forbid")),
+        BuiltinSchema.Entry("time", "consumeTime",
+            BuiltinSchema.OptionalParameter("value_range", values={"[0,inf]": "ValueRange::NonNegative"}, default="ValueRange::All"),
+            BuiltinSchema.OptionalParameter("mode", values={"svg": "SVGAttributeMode", "strict": "HTMLStandardMode"}, default=None),
+            BuiltinSchema.OptionalParameter("unitless", values={"unitless-allowed": "UnitlessQuirk::Allow"}, default="UnitlessQuirk::Forbid")),
+        BuiltinSchema.Entry("integer", "consumeInteger",
+            BuiltinSchema.OptionalParameter("value_range", values={"[0,inf]": "IntegerValueRange::NonNegative", "[1,inf]": "IntegerValueRange::Positive"}, default="IntegerValueRange::All")),
+        BuiltinSchema.Entry("number", "consumeNumber",
+            BuiltinSchema.OptionalParameter("value_range", values={"[0,inf]": "ValueRange::NonNegative"}, default="ValueRange::All")),
+        BuiltinSchema.Entry("percentage", "consumePercent",
+            BuiltinSchema.OptionalParameter("value_range", values={"[0,inf]": "ValueRange::NonNegative"}, default="ValueRange::All")),
+        BuiltinSchema.Entry("position", "consumePosition",
+            BuiltinSchema.OptionalParameter("unitless", values={"unitless-allowed": "UnitlessQuirk::Allow"}, default="UnitlessQuirk::Forbid")),
+        BuiltinSchema.Entry("color", "consumeColor",
+            BuiltinSchema.OptionalParameter("quirky_colors", values={"accept-quirky-colors-in-quirks-mode": True}, default=False)),
+        BuiltinSchema.Entry("resolution", "consumeResolution"),
+        BuiltinSchema.Entry("string", "consumeString"),
+        BuiltinSchema.Entry("custom-ident", "consumeCustomIdent"),
+        BuiltinSchema.Entry("dashed-ident", "consumeDashedIdent"),
+        BuiltinSchema.Entry("url", "consumeURL"),
+    )
 
-    def _generate_css_property_names_gperf_heading(self, *, to):
-        to.write(textwrap.dedent("""\
-            %{
-            // This file is automatically generated from CSSProperties.json by the process-css-properties script. Do not edit it.
+    def __init__(self, **dictionary):
+        ReferenceTerm.schema.set_attributes_from_dictionary(dictionary, instance=self)
 
-            #include "config.h"
-            #include "CSSPropertyNames.h"
+        # Removes the '<' and '>' characters and splits on whitespace to get the parts.
+        parts = self.value[1:-1].split()
 
-            #include "CSSProperty.h"
-            #include "Settings.h"
-            #include <wtf/ASCIICType.h>
-            #include <wtf/Hasher.h>
-            #include <wtf/text/AtomString.h>
-            #include <string.h>
+        # Store the first (and perhaps only) part as the reference's name (e.g. for <length-percentage [0,inf] unitless-allowed> store 'length-percentage').
+        self.name = Name(parts[0])
 
-            IGNORE_WARNINGS_BEGIN("implicit-fallthrough")
+        # Store any remaining pars as the parameters (e.g. for <length-percentage [0,inf] unitless-allowed> store ['[0,inf]', 'unitless-allowed']).
+        self.parameters = parts[1:]
 
-            // Older versions of gperf like to use the `register` keyword.
-            #define register
+        # Check name and parameters against the builtins schemas to verify if they are well formed.
+        self.builtin = ReferenceTerm.builtins.validate_and_construct_if_builtin(self.name, self.parameters)
 
-            namespace WebCore {
+    def __str__(self):
+        return f"'{self.value}'"
 
-            // Using std::numeric_limits<uint16_t>::max() here would be cleaner,
-            // but is not possible due to missing constexpr support in MSVC 2013.
-            static_assert(numCSSProperties + 1 <= 65535, "CSSPropertyID should fit into uint16_t.");
+    def __repr__(self):
+        return self.__str__()
 
-            """))
+    @staticmethod
+    def is_reference_string(string):
+        string = string.strip()
+        return string.startswith('<') and string.endswith('>')
 
-        all_computed_property_ids = (f"{property.id}," for property in self.properties.all_computed)
-        to.write(f"const std::array<CSSPropertyID, {count_iterable(self.properties.all_computed)}> computedPropertyIDs {{")
-        to.write("\n    ")
-        to.write("\n    ".join(all_computed_property_ids))
-        to.write("\n};\n\n")
+    @staticmethod
+    def from_json(parsing_context, key_path, json_value):
+        assert(type(json_value) is dict)
+        ReferenceTerm.schema.validate_dictionary(parsing_context, key_path, json_value, label=f"ReferenceTerm")
 
-        all_property_name_strings = quote_iterable(self.properties.all, "_s,")
-        to.write(f"constexpr ASCIILiteral propertyNameStrings[numCSSProperties] = {{")
-        to.write("\n    ")
-        to.write("\n    ".join(all_property_name_strings))
-        to.write("\n};\n\n")
+        if "enable-if" in json_value and not parsing_context.is_enabled(conditional=json_value["enable-if"]):
+            if parsing_context.verbose:
+                print(f"SKIPPED grammar term {json_value['value']} in {key_path} due to failing to satisfy 'enable-if' condition, '{json_value['enable-if']}', with active macro set")
+            return None
 
-        to.write("%}\n")
+        return ReferenceTerm(**json_value)
 
-    def _generate_css_property_names_gperf_footing(self, *, to):
-        to.write(textwrap.dedent("""\
-            } // namespace WebCore
+    def perform_fixups(self, all_rules):
+        # Replace a reference with the term it references if it can be found.
+        if self.value in all_rules.rules_by_name:
+            return all_rules.rules_by_name[self.value].grammar.root_term
+        return self
 
-            IGNORE_WARNINGS_END
-            """))
+    def perform_fixups_for_values_references(self, values):
+        # NOTE: The actual name in the JSON is "<<values>>", but the out layer is stripped on construction.
+        if self.name.name == "<values>":
+            # FIXME: This should really return a "MatchOneTerm" if len(values) > 1 and not a list.
+            return [value.keyword_term for value in values]
+        return self
 
-    def _generate_gperf_definition(self, *, to):
-        to.write(textwrap.dedent("""\
-            %struct-type
-            struct CSSPropertyHashTableEntry {
-                const char* name;
-                uint16_t id;
-            };
-            %language=C++
-            %readonly-tables
-            %global-table
-            %7bit
-            %compare-strncmp
-            %define class-name CSSPropertyNamesHash
-            %enum
-            %%
-            """))
+    @property
+    def is_builtin(self):
+        return self.builtin is not None
 
-        # Concatenates a list of 'propererty-name, property-id' strings with a second list of 'property-alias, property-id' strings.
-        all_property_names_and_aliases_with_ids = itertools.chain(
-              [f'{property.name}, {property.id}'                        for property in self.properties.all],
-            *[[f'{alias}, {property.id}' for alias in property.aliases] for property in self.properties.all]
-        )
-        to.write("\n".join(all_property_names_and_aliases_with_ids))
 
-        to.write("\n%%\n")
+# KeywordTerm represents a direct keyword match. The syntax in the CSS specifications
+# is a bare string.
+#
+#   { "kind": "keyword", "value": "auto" }
+#
+# or using shorthand
+#
+#   "auto"
+class KeywordTerm:
+    schema = Term.schema + Schema(
+        Schema.Entry("aliased-to", allowed_types=[str], convert_to=ValueKeywordName),
+        Schema.Entry("settings-flag", allowed_types=[str]),
+        Schema.Entry("value", allowed_types=[str], required=True, convert_to=ValueKeywordName),
+    )
 
-    def _generate_lookup_functions(self, *, to):
-        to.write(textwrap.dedent("""
-            CSSPropertyID findCSSProperty(const char* characters, unsigned length)
-            {
-                auto* value = CSSPropertyNamesHash::in_word_set(characters, length);
-                return value ? static_cast<CSSPropertyID>(value->id) : CSSPropertyID::CSSPropertyInvalid;
-            }
+    def __init__(self, **dictionary):
+        KeywordTerm.schema.set_attributes_from_dictionary(dictionary, instance=self)
 
-            ASCIILiteral nameLiteral(CSSPropertyID id)
-            {
-                if (id < firstCSSProperty)
-                    return { };
-                unsigned index = id - firstCSSProperty;
-                if (index >= numCSSProperties)
-                    return { };
-                return propertyNameStrings[index];
-            }
+    def __str__(self):
+        return f"'{self.value}'"
 
-            const AtomString& nameString(CSSPropertyID id)
-            {
-                if (id < firstCSSProperty)
-                    return nullAtom();
-                unsigned index = id - firstCSSProperty;
-                if (index >= numCSSProperties)
-                    return nullAtom();
+    def __repr__(self):
+        return self.__str__()
 
-                static NeverDestroyed<std::array<AtomString, numCSSProperties>> atomStrings;
-                auto& string = atomStrings.get()[index];
-                if (string.isNull())
-                    string = propertyNameStrings[index];
-                return string;
-            }
+    @staticmethod
+    def from_json(parsing_context, key_path, json_value):
+        assert(type(json_value) is dict)
+        KeywordTerm.schema.validate_dictionary(parsing_context, key_path, json_value, label=f"KeywordTerm")
 
-            String nameForIDL(CSSPropertyID id)
-            {
-                LChar characters[maxCSSPropertyNameLength];
-                const char* nameForCSS = nameLiteral(id);
-                if (!nameForCSS)
-                    return emptyString();
+        if "enable-if" in json_value and not parsing_context.is_enabled(conditional=json_value["enable-if"]):
+            if parsing_context.verbose:
+                print(f"SKIPPED grammar term {json_value['value']} in {key_path} due to failing to satisfy 'enable-if' condition, '{json_value['enable-if']}', with active macro set")
+            return None
 
-                auto* propertyNamePointer = nameForCSS;
-                auto* nextCharacter = characters;
-                while (char character = *propertyNamePointer++) {
-                    if (character == '-') {
-                        char nextCharacter = *propertyNamePointer++;
-                        if (!nextCharacter)
-                            break;
-                        character = (propertyNamePointer - 2 != nameForCSS) ? toASCIIUpper(nextCharacter) : nextCharacter;
-                    }
-                    *nextCharacter++ = character;
-                }
-                unsigned length = nextCharacter - characters;
-                return { characters, length };
-            }
+        return KeywordTerm(**json_value)
 
-            """))
+    def perform_fixups(self, all_rules):
+        return self
 
-    def _generate_physical_logical_conversion_function(self, *, to, signature, source, destination, resolver_enum_prefix):
-        source_as_id = PropertyName.convert_name_to_id(source)
-        destination_as_id = PropertyName.convert_name_to_id(destination)
+    @property
+    def perform_fixups_for_values_references(self, values):
+        return self
+
+    @property
+    def requires_context(self):
+        return self.settings_flag or self.status == "internal"
+
+    @property
+    def is_eligible_for_fast_path(self):
+        # Keyword terms that are aliased as not eligable for the fast path as the fast
+        # path can only support a basic predicate.
+        return not self.aliased_to
+
+    @property
+    def name(self):
+        return self.value.name
+
+
+# MatchOneTerm represents a set of terms, only one of which can match. The
+# syntax in the CSS specifications is a '|' between terms.
+#
+#   {
+#       "kind": "match-one",
+#       "value": [
+#           "auto"
+#           "reverse",
+#           "<angle unitless-allowed unitless-zero-allowed>"
+#       ]
+#   }
+#
+# or using shorthand
+#
+#   ["auto", "reverse", "<angle unitless-allowed unitless-zero-allowed>"]
+#
+class MatchOneTerm:
+    schema = Term.schema + Schema(
+        Schema.Entry("value", allowed_types=[list], required=True),
+    )
+
+    def __init__(self, terms):
+        self.terms = terms
+
+    def __str__(self):
+        return f"[{' | '.join(map(lambda t: str(t), self.terms))}]"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def from_json(parsing_context, key_path, json_value):
+        assert(type(json_value) is dict)
+        MatchOneTerm.schema.validate_dictionary(parsing_context, key_path, json_value, label=f"MatchOneTerm")
+
+        if "enable-if" in json_value and not parsing_context.is_enabled(conditional=json_value["enable-if"]):
+            if parsing_context.verbose:
+                print(f"SKIPPED grammar term {json_value['value']} in {key_path} due to failing to satisfy 'enable-if' condition, '{json_value['enable-if']}', with active macro set")
+            return None
+
+        return MatchOneTerm(
+            list(compact_map(lambda value: Term.from_json(parsing_context, f"{key_path}", value), json_value["value"]))
+        )
+
+    def perform_fixups(self, all_rules):
+        updated_terms = []
+        for term in self.terms:
+            updated_term = term.perform_fixups(all_rules)
+            if isinstance(updated_term, MatchOneTerm):
+                updated_terms += updated_term.terms
+            else:
+                updated_terms += [updated_term]
+
+        self.terms = updated_terms
+
+        if len(self.terms) == 1:
+            return self.terms[0]
+        return self
+
+    def perform_fixups_for_values_references(self, values):
+        self.terms = flatten([term.perform_fixups_for_values_references(values) for term in self.terms])
+        return self
+
+    @property
+    def is_values_reference(self):
+        return False
+
+    @property
+    def has_keyword_term(self):
+        return any(isinstance(term, KeywordTerm) for term in self.terms)
+
+    @property
+    def has_only_keyword_terms(self):
+        return all(isinstance(term, KeywordTerm) for term in self.terms)
+
+    @property
+    def keyword_terms(self):
+        return (term for term in self.terms if isinstance(term, KeywordTerm))
+
+    @property
+    def fast_path_keyword_terms(self):
+        return (term for term in self.keyword_terms if term.is_eligible_for_fast_path)
+
+    @property
+    def has_fast_path_keyword_terms(self):
+        return any(term.is_eligible_for_fast_path for term in self.keyword_terms)
+
+    @property
+    def has_only_fast_path_keyword_terms(self):
+        return all(isinstance(term, KeywordTerm) and term.is_eligible_for_fast_path for term in self.terms)
+
+
+# Container for the name and root term for a grammar. Used for both shared rules and property specific grammars.
+class Grammar:
+    def __init__(self, name, root_term):
+        self.name = name
+        self.root_term = root_term
+
+    def __str__(self):
+        return f"{self.name} {self.root_term}"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def from_json(parsing_context, key_path, name, json_value):
+        return Grammar(name, Term.from_json(parsing_context, key_path, json_value))
+
+    def perform_fixups(self, all_rules):
+        self.root_term = self.root_term.perform_fixups(all_rules)
+
+    def perform_fixups_for_values_references(self, values):
+        self.root_term = self.root_term.perform_fixups_for_values_references(values)
+
+    @property
+    def has_fast_path_keyword_terms(self):
+        if isinstance(self.root_term, MatchOneTerm) and self.root_term.has_fast_path_keyword_terms:
+            return True
+        return False
+
+    @property
+    def has_only_keyword_terms(self):
+        if isinstance(self.root_term, MatchOneTerm) and self.root_term.has_only_keyword_terms:
+            return True
+        return False
+
+    @property
+    def has_only_fast_path_keyword_terms(self):
+        if isinstance(self.root_term, MatchOneTerm) and self.root_term.has_only_fast_path_keyword_terms:
+            return True
+        return False
+
+    @property
+    def fast_path_keyword_terms(self):
+        if isinstance(self.root_term, MatchOneTerm):
+            return self.root_term.fast_path_keyword_terms
+        return []
+
+
+# A shared grammar rule and metadata describing it. Part of the set of rules tracked by SharedGrammarRules.
+class SharedGrammarRule:
+    schema = Schema(
+        Schema.Entry("comment", allowed_types=[str]),
+        Schema.Entry("exported", allowed_types=[bool], default_value=False),
+        Schema.Entry("grammar", allowed_types=[list, dict], required=True),
+        Schema.Entry("specification", allowed_types=[dict], convert_to=Specification),
+        Schema.Entry("status", allowed_types=[dict, str], convert_to=Status),
+    )
+
+    def __init__(self, name, **dictionary):
+        SharedGrammarRule.schema.set_attributes_from_dictionary(dictionary, instance=self)
+        self.name = name
+        self.name_for_methods = Name(name[1:-1])
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def from_json(parsing_context, key_path, name, json_value):
+        assert(type(json_value) is dict)
+        SharedGrammarRule.schema.validate_dictionary(parsing_context, f"{key_path}.{name}", json_value, label=f"SharedGrammarRule")
+
+        json_value["grammar"] = Grammar.from_json(parsing_context, f"{key_path}.{name}", name, json_value["grammar"])
+
+        return SharedGrammarRule(name, **json_value)
+
+    def perform_fixups(self, all_rules):
+        self.grammar.perform_fixups(all_rules)
+
+
+# Shared grammar rules used to aid in defining property specific grammars.
+class SharedGrammarRules:
+    def __init__(self, *rules):
+        self.rules = rules
+        self.rules_by_name = {rule.name: rule for rule in rules}
+        self._all = None
+
+        self._perform_fixups()
+
+    def __str__(self):
+        return "SharedGrammarRules"
+
+    def __repr__(self):
+        return self.__str__()
+
+    # Updates any references to other rules with a direct reference to the rule object.
+    def _perform_fixups(self):
+        for rule in self.rules:
+            rule.perform_fixups(self)
+
+    # Returns the set of all shared property rules sorted by name.
+    @property
+    def all(self):
+        if not self._all:
+            self._all = sorted(self.rules, key=lambda rule: rule.name)
+        return self._all
+
+
+class ParsingContext:
+    class TopLevelObject:
+        schema = Schema(
+            Schema.Entry("categories", allowed_types=[dict], required=True),
+            Schema.Entry("instructions", allowed_types=[list], required=True),
+            Schema.Entry("properties", allowed_types=[dict], required=True),
+            Schema.Entry("shared-grammar-rules", allowed_types=[dict], required=True),
+        )
+
+    def __init__(self, json_value, *, defines_string, parsing_for_codegen, verbose):
+        ParsingContext.TopLevelObject.schema.validate_dictionary(self, "$", json_value, label="top level object")
+
+        self.json_value = json_value
+        self.conditionals = frozenset((defines_string or '').split(' '))
+        self.parsing_for_codegen = parsing_for_codegen
+        self.verbose = verbose
+        self.parsed_shared_grammar_rules = None
+        self.parsed_properties = None
+
+    def parse_shared_grammar_rules(self):
+        self.parsed_shared_grammar_rules = SharedGrammarRules(
+            *list(
+                filter(
+                    lambda value: value is not None,
+                    map(
+                        lambda item: SharedGrammarRule.from_json(self, "$shared-grammar-rules", item[0], item[1]),
+                        self.json_value["shared-grammar-rules"].items()
+                    )
+                )
+            )
+        )
+
+    def parse_properties(self):
+        self.parsed_properties = Properties(
+            *list(
+                filter(
+                    lambda value: value is not None,
+                    map(
+                        lambda item: Property.from_json(self, "$properties", item[0], item[1]),
+                        self.json_value["properties"].items()
+                    )
+                )
+            )
+        )
+
+    def is_enabled(self, *, conditional):
+        if conditional[0] == '!':
+            return conditional[1:] not in self.conditionals
+        return conditional in self.conditionals
+
+    def select_enabled_variant(self, variants, *, label):
+        for variant in variants:
+            if "enable-if" not in variant:
+                raise Exception(f"Invalid conditional definition for '{label}'. No 'enable-if' property found.")
+
+            if self.is_enabled(conditional=variant["enable-if"]):
+                return variant
+
+        raise Exception(f"Invalid conditional definition for '{label}'. No 'enable-if' property matched the active set.")
+
+
+# MARK: - Code Generation
+
+class GenerationContext:
+    def __init__(self, properties, shared_grammar_rules, *, verbose, gperf_executable):
+        self.properties = properties
+        self.shared_grammar_rules = shared_grammar_rules
+        self.verbose = verbose
+        self.gperf_executable = gperf_executable
+
+    # Shared generation constants.
+
+    number_of_predefined_properties = 2
+
+    # Shared generator templates.
+
+    def generate_heading(self, *, to):
+        to.write("// This file is automatically generated from CSSProperties.json by the process-css-properties script. Do not edit it.\n")
+
+    def generate_open_namespace(self, *, to, namespace):
+        if not namespace:
+            to.write(f"namespace {{\n\n")
+        else:
+            to.write(f"namespace {namespace} {{\n\n")
+
+    def generate_close_namespace(self, *, to, namespace):
+        if not namespace:
+            to.write(f"}} // namespace (anonymous)\n")
+        else:
+            to.write(f"}} // namespace {namespace}\n")
+
+    def generate_using_namespace_declarations(self, *, to, namespaces):
+        for namespace in namespaces:
+            to.write(f"using namespace {namespace};\n")
+
+    def generate_property_id_switch_function(self, *, to, signature, properties, mapping, default, prologue=None, epilogue=None):
+        to.write(f"{signature}\n")
+        to.write(f"{{\n")
+
+        if prologue:
+            to.write(textwrap.indent(prologue, '    ') + "\n")
+
+        to.write(f"    switch (id) {{\n")
+
+        for property in properties:
+            to.write(f"    case {property.id}:\n")
+            to.write(f"        {mapping(property)}\n")
+
+        to.write(f"    default:\n")
+        to.write(f"        {default}\n")
+        to.write(f"    }}\n")
+
+        if epilogue:
+            to.write(textwrap.indent(epilogue, '    ') + "\n")
+
+        to.write(f"}}\n\n")
+
+    def generate_property_id_switch_function_bool(self, *, to, signature, properties):
+        to.write(f"{signature}\n")
+        to.write(f"{{\n")
+        to.write(f"    switch (id) {{\n")
+
+        for property in properties:
+            to.write(f"    case {property.id}:\n")
+
+        to.write(f"        return true;\n")
+        to.write(f"    default:\n")
+        to.write(f"        return false;\n")
+        to.write(f"    }}\n")
+        to.write(f"}}\n\n")
+
+
+# Generates `CSSPropertyNames.h` and `CSSPropertyNames.cpp`.
+class GenerateCSSPropertyNames:
+    def __init__(self, generation_context):
+        self.generation_context = generation_context
+
+    @property
+    def properties(self):
+        return self.generation_context.properties
+
+    def generate(self):
+        self.generate_css_property_names_h()
+        self.generate_css_property_names_gperf()
+        self.run_gperf()
+
+    # Runs `gperf` on the output of the generated file CSSPropertyNames.gperf
+    def run_gperf(self):
+        gperf_command = self.generation_context.gperf_executable or os.environ['GPERF']
+
+        gperf_result_code = subprocess.call([gperf_command, '--key-positions=*', '-D', '-n', '-s', '2', 'CSSPropertyNames.gperf', '--output-file=CSSPropertyNames.cpp'])
+        if gperf_result_code != 0:
+            raise Exception(f"Error when generating CSSPropertyNames.cpp from CSSPropertyNames.gperf: {gperf_result_code}")
+
+    # MARK: - Helper generator functions for CSSPropertyNames.h
+
+    def _generate_css_property_names_gperf_heading(self, *, to):
+        to.write(textwrap.dedent("""\
+            %{
+            // This file is automatically generated from CSSProperties.json by the process-css-properties script. Do not edit it.
+
+            #include "config.h"
+            #include "CSSPropertyNames.h"
+
+            #include "CSSProperty.h"
+            #include "Settings.h"
+            #include <wtf/ASCIICType.h>
+            #include <wtf/Hasher.h>
+            #include <wtf/text/AtomString.h>
+            #include <string.h>
+
+            IGNORE_WARNINGS_BEGIN("implicit-fallthrough")
+
+            // Older versions of gperf like to use the `register` keyword.
+            #define register
+
+            namespace WebCore {
+
+            // Using std::numeric_limits<uint16_t>::max() here would be cleaner,
+            // but is not possible due to missing constexpr support in MSVC 2013.
+            static_assert(numCSSProperties + 1 <= 65535, "CSSPropertyID should fit into uint16_t.");
+
+            """))
+
+        all_computed_property_ids = (f"{property.id}," for property in self.properties.all_computed)
+        to.write(f"const std::array<CSSPropertyID, {count_iterable(self.properties.all_computed)}> computedPropertyIDs {{")
+        to.write("\n    ")
+        to.write("\n    ".join(all_computed_property_ids))
+        to.write("\n};\n\n")
+
+        all_property_name_strings = quote_iterable(self.properties.all, "_s,")
+        to.write(f"constexpr ASCIILiteral propertyNameStrings[numCSSProperties] = {{")
+        to.write("\n    ")
+        to.write("\n    ".join(all_property_name_strings))
+        to.write("\n};\n\n")
+
+        to.write("%}\n")
+
+    def _generate_css_property_names_gperf_footing(self, *, to):
+        to.write(textwrap.dedent("""\
+            } // namespace WebCore
+
+            IGNORE_WARNINGS_END
+            """))
+
+    def _generate_gperf_definition(self, *, to):
+        to.write(textwrap.dedent("""\
+            %struct-type
+            struct CSSPropertyHashTableEntry {
+                const char* name;
+                uint16_t id;
+            };
+            %language=C++
+            %readonly-tables
+            %global-table
+            %7bit
+            %compare-strncmp
+            %define class-name CSSPropertyNamesHash
+            %enum
+            %%
+            """))
+
+        # Concatenates a list of 'propererty-name, property-id' strings with a second list of 'property-alias, property-id' strings.
+        all_property_names_and_aliases_with_ids = itertools.chain(
+              [f'{property.name}, {property.id}'                        for property in self.properties.all],
+            *[[f'{alias}, {property.id}' for alias in property.aliases] for property in self.properties.all]
+        )
+        to.write("\n".join(all_property_names_and_aliases_with_ids))
+
+        to.write("\n%%\n")
+
+    def _generate_lookup_functions(self, *, to):
+        to.write(textwrap.dedent("""
+            CSSPropertyID findCSSProperty(const char* characters, unsigned length)
+            {
+                auto* value = CSSPropertyNamesHash::in_word_set(characters, length);
+                return value ? static_cast<CSSPropertyID>(value->id) : CSSPropertyID::CSSPropertyInvalid;
+            }
+
+            ASCIILiteral nameLiteral(CSSPropertyID id)
+            {
+                if (id < firstCSSProperty)
+                    return { };
+                unsigned index = id - firstCSSProperty;
+                if (index >= numCSSProperties)
+                    return { };
+                return propertyNameStrings[index];
+            }
+
+            const AtomString& nameString(CSSPropertyID id)
+            {
+                if (id < firstCSSProperty)
+                    return nullAtom();
+                unsigned index = id - firstCSSProperty;
+                if (index >= numCSSProperties)
+                    return nullAtom();
+
+                static NeverDestroyed<std::array<AtomString, numCSSProperties>> atomStrings;
+                auto& string = atomStrings.get()[index];
+                if (string.isNull())
+                    string = propertyNameStrings[index];
+                return string;
+            }
+
+            String nameForIDL(CSSPropertyID id)
+            {
+                LChar characters[maxCSSPropertyNameLength];
+                const char* nameForCSS = nameLiteral(id);
+                if (!nameForCSS)
+                    return emptyString();
+
+                auto* propertyNamePointer = nameForCSS;
+                auto* nextCharacter = characters;
+                while (char character = *propertyNamePointer++) {
+                    if (character == '-') {
+                        char nextCharacter = *propertyNamePointer++;
+                        if (!nextCharacter)
+                            break;
+                        character = (propertyNamePointer - 2 != nameForCSS) ? toASCIIUpper(nextCharacter) : nextCharacter;
+                    }
+                    *nextCharacter++ = character;
+                }
+                unsigned length = nextCharacter - characters;
+                return { characters, length };
+            }
+
+            """))
+
+    def _generate_physical_logical_conversion_function(self, *, to, signature, source, destination, resolver_enum_prefix):
+        source_as_id = PropertyName.convert_name_to_id(source)
+        destination_as_id = PropertyName.convert_name_to_id(destination)
 
         to.write(f"{signature}\n")
         to.write(f"{{\n")
@@ -1161,7 +1775,7 @@ def _generate_physical_logical_conversion_function(self, *, to, signature, sourc
         to.write(f"}}\n\n")
 
     def _generate_is_exposed_functions(self, *, to):
-        self._generate_property_id_switch_function(
+        self.generation_context.generate_property_id_switch_function(
             to=to,
             signature="static bool isExposedNotInvalidAndNotInternal(CSSPropertyID id, const CSSPropertySettings& settings)",
             properties=self.properties.all_with_settings_flag,
@@ -1169,7 +1783,7 @@ def _generate_is_exposed_functions(self, *, to):
             default="return true;"
         )
 
-        self._generate_property_id_switch_function(
+        self.generation_context.generate_property_id_switch_function(
             to=to,
             signature="static bool isExposedNotInvalidAndNotInternal(CSSPropertyID id, const Settings& settings)",
             properties=self.properties.all_with_settings_flag,
@@ -1212,7 +1826,7 @@ def _generate_is_exposed_functions(self, *, to):
         """))
 
     def _generate_is_inherited_property(self, *, to):
-        to.write(f'constexpr bool isInheritedPropertyTable[numCSSProperties + {GenerationContext.number_of_predefined_properties}] = {{\n')
+        to.write(f'\nconstexpr bool isInheritedPropertyTable[numCSSProperties + {GenerationContext.number_of_predefined_properties}] = {{\n')
         to.write(f'    false, // CSSPropertyID::CSSPropertyInvalid\n')
         to.write(f'    true , // CSSPropertyID::CSSPropertyCustom\n')
 
@@ -1302,7 +1916,7 @@ def generate_css_property_names_gperf(self):
                 to=output_file
             )
 
-            self._generate_property_id_switch_function_bool(
+            self.generation_context.generate_property_id_switch_function_bool(
                 to=output_file,
                 signature="bool isInternal(CSSPropertyID id)",
                 properties=self.properties.all_internal_only
@@ -1316,7 +1930,7 @@ def generate_css_property_names_gperf(self):
                 to=output_file
             )
 
-            self._generate_property_id_switch_function(
+            self.generation_context.generate_property_id_switch_function(
                 to=output_file,
                 signature="CSSPropertyID relatedProperty(CSSPropertyID id)",
                 properties=(p for p in self.properties.all if p.codegen_properties.related_property),
@@ -1324,7 +1938,7 @@ def generate_css_property_names_gperf(self):
                 default="return CSSPropertyID::CSSPropertyInvalid;"
             )
 
-            self._generate_property_id_switch_function(
+            self.generation_context.generate_property_id_switch_function(
                 to=output_file,
                 signature="Vector<String> CSSProperty::aliasesForProperty(CSSPropertyID id)",
                 properties=(p for p in self.properties.all if p.codegen_properties.aliases),
@@ -1332,13 +1946,13 @@ def generate_css_property_names_gperf(self):
                 default="return { };"
             )
 
-            self._generate_property_id_switch_function_bool(
+            self.generation_context.generate_property_id_switch_function_bool(
                 to=output_file,
                 signature="bool CSSProperty::isColorProperty(CSSPropertyID id)",
                 properties=(p for p in self.properties.all if p.codegen_properties.color_property)
             )
 
-            self._generate_property_id_switch_function(
+            self.generation_context.generate_property_id_switch_function(
                 to=output_file,
                 signature="UChar CSSProperty::listValuedPropertySeparator(CSSPropertyID id)",
                 properties=(p for p in self.properties.all if p.codegen_properties.separator),
@@ -1347,13 +1961,13 @@ def generate_css_property_names_gperf(self):
                 epilogue="return '\\0';"
             )
 
-            self._generate_property_id_switch_function_bool(
+            self.generation_context.generate_property_id_switch_function_bool(
                 to=output_file,
                 signature="bool CSSProperty::isDirectionAwareProperty(CSSPropertyID id)",
                 properties=self.properties.all_direction_aware_properties
             )
 
-            self._generate_property_id_switch_function_bool(
+            self.generation_context.generate_property_id_switch_function_bool(
                 to=output_file,
                 signature="bool CSSProperty::isInLogicalPropertyGroup(CSSPropertyID id)",
                 properties=self.properties.all_in_logical_property_group
@@ -1379,7 +1993,7 @@ def generate_css_property_names_gperf(self):
                 resolver_enum_prefix="Box"
             )
 
-            self._generate_property_id_switch_function_bool(
+            self.generation_context.generate_property_id_switch_function_bool(
                 to=output_file,
                 signature="bool CSSProperty::isDescriptorOnly(CSSPropertyID id)",
                 properties=(p for p in self.properties.all if p.codegen_properties.descriptor_only)
@@ -1600,6 +2214,19 @@ def generate_css_property_names_h(self):
                 to=output_file
             )
 
+
+# Generates `CSSStyleDeclaration+PropertyNames.idl`.
+class GenerateCSSStyleDeclarationPropertyNames:
+    def __init__(self, generation_context):
+        self.generation_context = generation_context
+
+    @property
+    def properties(self):
+        return self.generation_context.properties
+
+    def generate(self):
+        self.generate_css_style_declaration_property_names_idl()
+
     # MARK: - Helper generator functions for CSSStyleDeclaration+PropertyNames.idl
 
     def _generate_css_style_declaration_property_names_idl_heading(self, *, to):
@@ -1638,7 +2265,7 @@ def _generate_css_style_declaration_property_names_idl_section(self, *, to, comm
 
         for name_or_alias, property in names_and_aliases_with_properties:
             if convert_to_idl_attribute:
-                idl_attribute_name = GenerationContext._convert_css_property_to_idl_attribute(name_or_alias, lowercase_first=lowercase_first)
+                idl_attribute_name = GenerateCSSStyleDeclarationPropertyNames._convert_css_property_to_idl_attribute(name_or_alias, lowercase_first=lowercase_first)
             else:
                 idl_attribute_name = name_or_alias
 
@@ -1728,6 +2355,19 @@ def generate_css_style_declaration_property_names_idl(self):
                 to=output_file
             )
 
+
+# Generates `StyleBuilderGenerated.cpp`.
+class GenerateStyleBuilderGenerated:
+    def __init__(self, generation_context):
+        self.generation_context = generation_context
+
+    @property
+    def properties(self):
+        return self.generation_context.properties
+
+    def generate(self):
+        self.generate_style_builder_generated_cpp()
+
     # MARK: - Helper generator functions for StyleBuilderGenerated.cpp
 
     def _generate_style_builder_generated_cpp_heading(self, *, to):
@@ -2122,6 +2762,20 @@ def generate_style_builder_generated_cpp(self):
                 to=output_file
             )
 
+
+# Generates `StylePropertyShorthandFunctions.h` and `StylePropertyShorthandFunctions.cpp`.
+class GenerateStylePropertyShorthandFunctions:
+    def __init__(self, generation_context):
+        self.generation_context = generation_context
+
+    @property
+    def properties(self):
+        return self.generation_context.properties
+
+    def generate(self):
+        self.generate_style_property_shorthand_functions_h()
+        self.generate_style_property_shorthand_functions_cpp()
+
     # MARK: - Helper generator functions for StylePropertyShorthandFunctions.h
 
     def _generate_style_property_shorthand_functions_h_heading(self, *, to):
@@ -2247,291 +2901,1033 @@ def generate_style_property_shorthand_functions_cpp(self):
                 shorthand_to_longhand_count=shorthand_to_longhand_count
             )
 
-            self._generate_property_id_switch_function(
-                to=output_file,
-                signature="StylePropertyShorthand shorthandForProperty(CSSPropertyID id)",
-                properties=self.properties.all_shorthands,
-                mapping=lambda p: f"return {p.id_without_prefix_with_lowercase_first_letter}Shorthand();",
-                default="return { };"
-            )
+            self.generation_context.generate_property_id_switch_function(
+                to=output_file,
+                signature="StylePropertyShorthand shorthandForProperty(CSSPropertyID id)",
+                properties=self.properties.all_shorthands,
+                mapping=lambda p: f"return {p.id_without_prefix_with_lowercase_first_letter}Shorthand();",
+                default="return { };"
+            )
+
+            self._generate_style_property_shorthand_functions_matching_shorthands_for_longhand(
+                to=output_file,
+                longhand_to_shorthands=longhand_to_shorthands,
+                shorthand_to_longhand_count=shorthand_to_longhand_count
+            )
+
+            self._generate_style_property_shorthand_functions_cpp_footing(
+                to=output_file
+            )
+
+
+# Generates `CSSPropertyParsing.h` and `CSSPropertyParsing.cpp`.
+class GenerateCSSPropertyParsing:
+    def __init__(self, generation_context):
+        self.generation_context = generation_context
+
+        # Create a handler for each property and add it to the `property_consumers` map.
+        self.property_consumers = {property: PropertyConsumer.make(property) for property in generation_context.properties.all}
+        self.shared_grammar_rule_consumers = {shared_grammar_rule: SharedGrammarRuleConsumer.make(shared_grammar_rule) for shared_grammar_rule in generation_context.shared_grammar_rules.all}
+
+    def generate(self):
+        self.generate_css_property_parsing_h()
+        self.generate_css_property_parsing_cpp()
+
+    @property
+    def properties(self):
+        return self.generation_context.properties
+
+    @property
+    def shared_grammar_rules(self):
+        return self.generation_context.shared_grammar_rules
+
+    @property
+    def all_property_consumers(self):
+        return (self.property_consumers[property] for property in self.properties.all)
+
+    @property
+    def all_shared_grammar_rule_consumers(self):
+        return (self.shared_grammar_rule_consumers[shared_grammar_rule] for shared_grammar_rule in self.shared_grammar_rules.all)
+
+    def generate_css_property_parsing_h(self):
+        with open('CSSPropertyParsing.h', 'w') as output_file:
+            self.generation_context.generate_heading(
+                to=output_file
+            )
+
+            self._generate_css_property_parsing_h_includes(
+                to=output_file
+            )
+
+            self.generation_context.generate_open_namespace(
+                to=output_file,
+                namespace="WebCore"
+            )
+
+            self._generate_css_property_parsing_h_forward_declarations(
+                to=output_file
+            )
+
+            self._generate_css_property_parsing_h_property_parsing_declaration(
+                to=output_file
+            )
+
+            self.generation_context.generate_close_namespace(
+                to=output_file,
+                namespace="WebCore"
+            )
+
+    def generate_css_property_parsing_cpp(self):
+        with open('CSSPropertyParsing.cpp', 'w') as output_file:
+            self.generation_context.generate_heading(
+                to=output_file
+            )
+
+            self._generate_css_property_parsing_cpp_includes(
+                to=output_file
+            )
+
+            self.generation_context.generate_open_namespace(
+                to=output_file,
+                namespace="WebCore"
+            )
+
+            self.generation_context.generate_using_namespace_declarations(
+                to=output_file,
+                namespaces=["CSSPropertyParserHelpers", "CSSPropertyParserHelpersWorkerSafe"]
+            )
+
+            self._generate_css_property_parsing_cpp_property_parsing_functions(
+                to=output_file
+            )
+
+            self._generate_css_property_parsing_cpp_parse(
+                to=output_file
+            )
+
+            self._generate_css_property_parsing_cpp_is_keyword_valid_aggregate(
+                to=output_file
+            )
+
+            self.generation_context.generate_property_id_switch_function_bool(
+                to=output_file,
+                signature="bool CSSPropertyParsing::isKeywordProperty(CSSPropertyID id)",
+                properties=self.properties.all_with_fast_path_keyword_terms,
+            )
+
+            self.generation_context.generate_close_namespace(
+                to=output_file,
+                namespace="WebCore"
+            )
+
+    # MARK: - Helper generator functions for CSSPropertyParsing.h
+
+    def _generate_css_property_parsing_h_includes(self, *, to):
+        to.write(textwrap.dedent("""
+            #pragma once
+
+            #include "CSSPropertyNames.h"
+            #include "CSSValueKeywords.h"
+
+            """))
+
+    def _generate_css_property_parsing_h_forward_declarations(self, *, to):
+        to.write(textwrap.dedent("""\
+            class CSSParserTokenRange;
+            class CSSValue;
+            struct CSSParserContext;
+            """))
+
+    def _generate_css_property_parsing_h_property_parsing_declaration(self, *, to):
+        to.write(textwrap.dedent("""
+            struct CSSPropertyParsing {
+                // Parse and return a single value.
+                static RefPtr<CSSValue> parse(CSSParserTokenRange&, CSSPropertyID id, CSSPropertyID currentShorthand, const CSSParserContext&);
+
+                // Returns true if the bare keyword value forms a valid construction when used with the
+                // provided property.
+                static bool isKeywordValidForProperty(CSSPropertyID, CSSValueID, const CSSParserContext&);
+
+                // Returns true for properties that are valid to pass to `isKeywordValidForProperty`. This
+                // corresponds to the set of properties where a bare keyword value is a valid construction.
+                // NOTE: This will return true for properties that allow values that aren't keywords. All
+                // that it validates is that the property can be valid with a keyword value. (For example,
+                // 'list-style-type' supports a litany of keyword values, but also supports a string value.)
+                static bool isKeywordProperty(CSSPropertyID);
+
+            """))
+
+        for property_consumer in self.all_property_consumers:
+            property_consumer.generate_export_declaration(to=to)
+
+        for shared_grammar_rule_consumer in self.all_shared_grammar_rule_consumers:
+            shared_grammar_rule_consumer.generate_export_declaration(to=to)
+
+        to.write("};\n\n")
+
+    # MARK: - Helper generator functions for CSSPropertyParsing.cpp
+
+    def _generate_css_property_parsing_cpp_includes(self, *, to):
+        to.write(textwrap.dedent("""
+            #include "config.h"
+            #include "CSSPropertyParsing.h"
+
+            #include "CSSParserContext.h"
+            #include "CSSParserIdioms.h"
+            #include "CSSPropertyParser.h"
+            #include "CSSPropertyParserWorkerSafe.h"
+            #include "CSSValuePool.h"
+            #include "DeprecatedGlobalSettings.h"
+
+            """))
+
+    def _generate_css_property_parsing_cpp_is_keyword_valid_aggregate(self, *, to):
+        to.write(f"bool CSSPropertyParsing::isKeywordValidForProperty(CSSPropertyID id, CSSValueID keyword, const CSSParserContext& context)\n")
+        to.write(f"{{\n")
+
+        to.write(f"    switch (id) {{\n")
+
+        for property_consumer in self.all_property_consumers:
+            keyword_fast_path_generator = property_consumer.keyword_fast_path_generator
+            if not keyword_fast_path_generator:
+                continue
+
+            to.write(f"    case {property_consumer.property.id}:\n")
+            to.write(f"        return {keyword_fast_path_generator.generate_call_string(keyword_string='keyword', context_string='context')};\n")
+
+        to.write(f"    default:\n")
+        to.write(f"        return false;\n")
+        to.write(f"    }}\n")
+        to.write(f"}}\n\n")
+
+    def _generate_css_property_parsing_cpp_property_parsing_functions(self, *, to):
+        to.write("\n")
+        # First generate definitions for all the keyword-only fast path predicate functions.
+        for property_consumer in self.all_property_consumers:
+            keyword_fast_path_generator = property_consumer.keyword_fast_path_generator
+            if not keyword_fast_path_generator:
+                continue
+            keyword_fast_path_generator.generate_definition(to=to)
+
+        # Then all the non-exported consume functions (these will be static functions).
+        for property_consumer in self.all_property_consumers:
+            if not property_consumer.property.codegen_properties.parser_exported:
+                property_consumer.generate_definition(to=to)
+
+        # Then all the exported consume functions (these will be static members of the CSSPropertyParsing struct).
+        for property_consumer in self.all_property_consumers:
+            if property_consumer.property.codegen_properties.parser_exported:
+                property_consumer.generate_definition(to=to)
+
+        # And finally all the exported shared grammar rule consumers.
+        for shared_grammar_rule_consumer in self.all_shared_grammar_rule_consumers:
+            shared_grammar_rule_consumer.generate_definition(to=to)
+
+    def _generate_css_property_parsing_cpp_parse(self, *, to):
+        to.write(f"RefPtr<CSSValue> CSSPropertyParsing::parse(CSSParserTokenRange& range, CSSPropertyID id, CSSPropertyID currentShorthand, const CSSParserContext& context)\n")
+        to.write(f"{{\n")
+        to.write(f"    if (!isExposed(id, context.propertySettings) && !isInternal(id)) {{\n")
+        to.write(f"        // Allow internal properties as we use them to parse several internal-only-shorthands (e.g. background-repeat),\n")
+        to.write(f"        // and to handle certain DOM-exposed values (e.g. -webkit-font-size-delta from execCommand('FontSizeDelta')).\n")
+        to.write(f"        ASSERT_NOT_REACHED();\n")
+        to.write(f"        return nullptr;\n")
+        to.write(f"    }}\n\n")
+
+        # Build up a list of pairs of (property, return-expression-to-use-for-property).
+
+        PropertyReturnExpression = collections.namedtuple('PropertyReturnExpression', ['property', 'return_expression'])
+        property_and_return_expressions = []
+
+        for property_consumer in self.all_property_consumers:
+            return_expression = property_consumer.generate_call_string(
+                range_string="range",
+                id_string="id",
+                current_shorthand_string="currentShorthand",
+                context_string="context")
+
+            if return_expression is None:
+                continue
+
+            property_and_return_expressions.append(
+                PropertyReturnExpression(property_consumer.property, return_expression))
+
+        # Take the list of pairs of (value, return-expression-to-use-for-value), and
+        # group them by their 'return-expression' to avoid unnecessary duplication of
+        # return statements.
+
+        PropertiesReturnExpression = collections.namedtuple('PropertiesReturnExpression', ['properties', 'return_expression'])
+
+        property_and_return_expressions_sorted_by_expression = sorted(property_and_return_expressions, key=lambda x: x.return_expression)
+        property_and_return_expressions_grouped_by_expression = []
+        for return_expression, group in itertools.groupby(property_and_return_expressions_sorted_by_expression, lambda x: x.return_expression):
+            properties = [property_and_return_expression.property for property_and_return_expression in group]
+            property_and_return_expressions_grouped_by_expression.append(PropertiesReturnExpression(properties, return_expression))
+
+        def _sort_by_first_property(a, b):
+            return Properties._sort_by_descending_priority_and_name(a.properties[0], b.properties[0])
+
+        to.write(f"    switch (id) {{\n")
+        for properties, return_expression in sorted(property_and_return_expressions_grouped_by_expression, key=functools.cmp_to_key(_sort_by_first_property)):
+            for property in properties:
+                to.write(f"    case {property.id}:\n")
+            to.write(f"        return {return_expression};\n")
+
+        to.write(f"    default:\n")
+        to.write(f"        return nullptr;\n")
+        to.write(f"    }}\n")
+        to.write(f"}}\n\n")
+
+
+# Helper class for representing a function parameter.
+class FunctionParameter:
+    def __init__(self, type, name):
+        self.type = type
+        self.name = name
+
+    @property
+    def declaration_string(self):
+        return f"{self.type}"
+
+    @property
+    def definition_string(self):
+        return f"{self.type} {self.name}"
+
+
+# Helper class for representing a function signature.
+class FunctionSignature:
+    def __init__(self, *, result_type, scope, name, parameters):
+        self.result_type = result_type
+        self.scope = scope
+        self.name = name
+        self.parameters = parameters
+
+    @property
+    def _declaration_parameters_string(self):
+        return ", ".join(parameter.declaration_string for parameter in self.parameters)
+
+    @property
+    def _definition_parameters_string(self):
+        return ", ".join(parameter.definition_string for parameter in self.parameters)
+
+    @property
+    def _scope_string(self):
+        return f"{self.scope}::" if self.scope else ""
+
+    @property
+    def declaration_string(self):
+        return f"{self.result_type} {self.name}({self._declaration_parameters_string})"
+
+    @property
+    def definition_string(self):
+        return f"{self.result_type} {self._scope_string}{self.name}({self._definition_parameters_string})"
+
+    @property
+    def reference_string(self):
+        return f"{self._scope_string}{self.name}"
+
+    def generate_call_string(self, parameters):
+        return f"{self._scope_string}{self.name}({', '.join(parameters)})"
+
+
+# The `TermGenerator` classes help generate parser functions by providing
+# generation of parsing text for a term or set of terms.
+class TermGenerator(object):
+    def make(term, keyword_fast_path_generator=None):
+        if isinstance(term, MatchOneTerm):
+            return TermGeneratorMatchOneTerm(term, keyword_fast_path_generator)
+        else:
+            raise Exception(f"Unexpected root term - {term}")
+
 
-            self._generate_style_property_shorthand_functions_matching_shorthands_for_longhand(
-                to=output_file,
-                longhand_to_shorthands=longhand_to_shorthands,
-                shorthand_to_longhand_count=shorthand_to_longhand_count
-            )
+class TermGeneratorMatchOneTerm(TermGenerator):
+    def __init__(self, term, keyword_fast_path_generator=None):
+        self.term = term
+        self.keyword_fast_path_generator = keyword_fast_path_generator
+        self.term_generators = TermGeneratorMatchOneTerm._build_term_generators(term, keyword_fast_path_generator)
+        self.requires_context = any(term_generator.requires_context for term_generator in self.term_generators)
 
-            self._generate_style_property_shorthand_functions_cpp_footing(
-                to=output_file
-            )
+    @staticmethod
+    def _build_term_generators(term, keyword_fast_path_generator):
+        # Partition the sub-terms into keywords and references (and eventually more things):
+        fast_path_keyword_terms = []
+        non_fast_path_keyword_terms = []
+        reference_terms = []
+
+        for sub_term in term.terms:
+            if isinstance(sub_term, KeywordTerm):
+                if keyword_fast_path_generator and sub_term.is_eligible_for_fast_path:
+                    fast_path_keyword_terms.append(sub_term)
+                else:
+                    non_fast_path_keyword_terms.append(sub_term)
+            elif isinstance(sub_term, ReferenceTerm):
+                reference_terms.append(sub_term)
+            else:
+                raise Exception(f"Only KeywordTerm and ReferenceTerm terms are supported inside MatchOneTerm at this time: '{term}' - {sub_term}")
+
+        # Build a list of generators for the terms, starting with all (if any) the keywords at once.
+        term_generators = []
+
+        if fast_path_keyword_terms:
+            term_generators += [TermGeneratorFastPathKeywordTerms(keyword_fast_path_generator)]
+        if non_fast_path_keyword_terms:
+            term_generators += [TermGeneratorNonFastPathKeywordTerm(non_fast_path_keyword_terms)]
+        if reference_terms:
+            term_generators += [TermGeneratorReferenceTerm(sub_term) for sub_term in reference_terms]
+        return term_generators
+
+    def generate_conditional(self, *, to, range_string, context_string):
+        # For any remaining generators, call the consume function and return the result if non-null.
+        for term_generator in self.term_generators:
+            term_generator.generate_conditional(to=to, range_string=range_string, context_string=context_string)
+
+    def generate_unconditional(self, *, to, range_string, context_string):
+        # Pop the last generator off, as that one will be the special, non-if case.
+        *remaining_term_generators, last_term_generator = self.term_generators
+
+        # For any remaining generators, call the consume function and return the result if non-null.
+        for term_generator in remaining_term_generators:
+            term_generator.generate_conditional(to=to, range_string=range_string, context_string=context_string)
+
+        # And finally call that last generator we popped of back.
+        last_term_generator.generate_unconditional(to=to, range_string=range_string, context_string=context_string)
+
+
+# Generation support for a single `ReferenceTerm`.
+class TermGeneratorReferenceTerm(TermGenerator):
+    def __init__(self, term):
+        self.term = term
+
+    def generate_conditional(self, *, to, range_string, context_string):
+        to.write(f"    if (auto result = {self.generate_call_string(range_string=range_string, context_string=context_string)})\n")
+        to.write(f"         return result;\n")
+
+    def generate_unconditional(self, *, to, range_string, context_string):
+        to.write(f"    return {self.generate_call_string(range_string=range_string, context_string=context_string)};\n")
+
+    def generate_call_string(self, *, range_string, context_string):
+        if self.term.is_builtin:
+            builtin = self.term.builtin
+            if isinstance(builtin, BuiltinAngleConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {context_string}.mode, {builtin.unitless}, {builtin.unitless_zero})"
+            elif isinstance(builtin, BuiltinTimeConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {context_string}.mode, {builtin.value_range}, {builtin.unitless})"
+            elif isinstance(builtin, BuiltinLengthConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {builtin.mode or f'{context_string}.mode'}, {builtin.value_range}, {builtin.unitless})"
+            elif isinstance(builtin, BuiltinLengthPercentageConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {builtin.mode or f'{context_string}.mode'}, {builtin.value_range}, {builtin.unitless})"
+            elif isinstance(builtin, BuiltinIntegerConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {builtin.value_range})"
+            elif isinstance(builtin, BuiltinNumberConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {builtin.value_range})"
+            elif isinstance(builtin, BuiltinPercentageConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {builtin.value_range})"
+            elif isinstance(builtin, BuiltinPositionConsumer):
+                return f"{builtin.consume_function_name}({range_string}, {context_string}.mode, {builtin.unitless}, PositionSyntax::Position)"
+            elif isinstance(builtin, BuiltinColorConsumer):
+                if builtin.quirky_colors:
+                    return f"{builtin.consume_function_name}({range_string}, {context_string}, {context_string}.mode == HTMLQuirksMode)"
+                return f"{builtin.consume_function_name}({range_string}, {context_string})"
+            elif isinstance(builtin, BuiltinResolutionConsumer):
+                return f"{builtin.consume_function_name}({range_string})"
+            elif isinstance(builtin, BuiltinStringConsumer):
+                return f"{builtin.consume_function_name}({range_string})"
+            elif isinstance(builtin, BuiltinCustomIdentConsumer):
+                return f"{builtin.consume_function_name}({range_string})"
+            elif isinstance(builtin, BuiltinDashedIdentConsumer):
+                return f"{builtin.consume_function_name}({range_string})"
+            elif isinstance(builtin, BuiltinURLConsumer):
+                return f"{builtin.consume_function_name}({range_string})"
+            else:
+                raise Exception(f"Unknown builtin type used: {builtin.name.name}")
+        else:
+            return f"consume{self.term.name.id_without_prefix}({range_string}, {context_string})"
 
-    # MARK: - Helper generator functions for CSSPropertyParsing.h
+    @property
+    def requires_context(self):
+        if self.term.is_builtin:
+            builtin = self.term.builtin
+            if isinstance(builtin, BuiltinAngleConsumer):
+                return True
+            elif isinstance(builtin, BuiltinTimeConsumer):
+                return True
+            elif isinstance(builtin, BuiltinLengthConsumer):
+                return builtin.mode is None
+            elif isinstance(builtin, BuiltinLengthPercentageConsumer):
+                return builtin.mode is None
+            elif isinstance(builtin, BuiltinIntegerConsumer):
+                return False
+            elif isinstance(builtin, BuiltinNumberConsumer):
+                return False
+            elif isinstance(builtin, BuiltinPercentageConsumer):
+                return False
+            elif isinstance(builtin, BuiltinPositionConsumer):
+                return True
+            elif isinstance(builtin, BuiltinColorConsumer):
+                return True
+            elif isinstance(builtin, BuiltinResolutionConsumer):
+                return False
+            elif isinstance(builtin, BuiltinStringConsumer):
+                return False
+            elif isinstance(builtin, BuiltinCustomIdentConsumer):
+                return False
+            elif isinstance(builtin, BuiltinDashedIdentConsumer):
+                return False
+            elif isinstance(builtin, BuiltinURLConsumer):
+                return False
+            else:
+                raise Exception(f"Unknown builtin type used: {builtin.name.name}")
+        else:
+            return True
 
-    def _generate_css_property_parsing_h_heading(self, *, to):
-        to.write(textwrap.dedent("""\
-            // This file is automatically generated from CSSProperties.json by the process-css-properties script. Do not edit it."
 
-            #pragma once
+# Generation support for any keyword terms that are not fast-path eligible.
+class TermGeneratorNonFastPathKeywordTerm(TermGenerator):
+    def __init__(self, keyword_terms):
+        self.keyword_terms = keyword_terms
+        self.requires_context = any(keyword_term.requires_context for keyword_term in self.keyword_terms)
 
-            #include "CSSPropertyNames.h"
-            #include "CSSValueKeywords.h"
+    def generate_conditional(self, *, to, range_string, context_string):
+        self._generate(to=to, range_string=range_string, context_string=context_string, default_string="break")
 
-            namespace WebCore {
+    def generate_unconditional(self, *, to, range_string, context_string, default_string):
+        self._generate(to=to, range_string=range_string, context_string=context_string, default_string="return nullptr")
 
-            class CSSParserTokenRange;
-            class CSSValue;
-            struct CSSParserContext;
-            """))
+    def _generate(self, *, to, range_string, context_string, default_string):
+        # Build up a list of pairs of (value, return-expression-to-use-for-value), taking
+        # into account settings flags and mode checks for internal values. Leave the return
+        # expression as an empty array for the default return expression "return true;".
 
-    def _generate_css_property_parsing_h_footing(self, *, to):
-        to.write(textwrap.dedent("""
-            } // namespace WebCore
-            """))
+        ReturnExpression = collections.namedtuple('ReturnExpression', ['conditions', 'return_value'])
+        KeywordTermAndReturnExpression = collections.namedtuple('KeywordTermAndReturnExpression', ['keyword_term', 'return_expression'])
+        keyword_term_and_return_expressions = []
 
-    def _generate_css_property_parsing_h_property_parsing_declaration(self, *, to):
-        to.write(textwrap.dedent("""
-            struct CSSPropertyParsing {
-                static RefPtr<CSSValue> parse(CSSParserTokenRange&, CSSPropertyID id, CSSPropertyID currentShorthand, const CSSParserContext&);
+        for keyword_term in self.keyword_terms:
+            conditions = []
+            if keyword_term.settings_flag:
+                if keyword_term.settings_flag.startswith("DeprecatedGlobalSettings::"):
+                    conditions.append(f"!{keyword_term.settings_flag}")
+                else:
+                    conditions.append(f"!{context_string}.{keyword_term.settings_flag}")
+            if keyword_term.status == "internal":
+                conditions.append(f"!isValueAllowedInMode(keyword, {context_string}.mode)")
 
-                // Returns true if the bare keyword value forms a valid construction when used with the
-                // provided property.
-                static bool isKeywordValidForProperty(CSSPropertyID, CSSValueID, const CSSParserContext&);
+            if keyword_term.aliased_to:
+                return_value = keyword_term.aliased_to.id
+            else:
+                return_value = "keyword"
 
-                // Returns true for properties that are valid to pass to `isKeywordValidForProperty`. This
-                // corresponds to the set of properties where a bare keyword value is a valid construction.
-                // NOTE: This will return true for properties that allow values that aren't keywords. All
-                // that it validates is that the property can be valid with a keyword value. (For example,
-                // 'list-style-type' supports a litany of keyword values, but also supports a string value.)
-                static bool isKeywordProperty(CSSPropertyID);
-            };
-            """))
+            keyword_term_and_return_expressions.append(KeywordTermAndReturnExpression(keyword_term, ReturnExpression(conditions, return_value)))
 
-    def generate_css_property_parsing_h(self):
-        with open('CSSPropertyParsing.h', 'w') as output_file:
-            self._generate_css_property_parsing_h_heading(
-                to=output_file
-            )
+        # Take the list of pairs of (value, return-expression-to-use-for-value), and
+        # group them by their 'return-expression' to avoid unnecessary duplication of
+        # return statements.
+        to.write(f"    switch (auto keyword = {range_string}.peek().id(); keyword) {{\n")
+        for return_expression, group in itertools.groupby(sorted(keyword_term_and_return_expressions, key=lambda x: x.return_expression), lambda x: x.return_expression):
+            for keyword_term, _ in group:
+                to.write(f"    case {keyword_term.value.id}:\n")
+            if return_expression.conditions:
+                to.write(f"        if ({' || '.join(return_expression.conditions)})\n")
+                to.write(f"            {default_string};\n")
+            to.write(f"        {range_string}.consumeIncludingWhitespace();\n")
+            to.write(f"        return CSSValuePool::singleton().createIdentifierValue({return_expression.return_value});\n")
 
-            self._generate_css_property_parsing_h_property_parsing_declaration(
-                to=output_file
-            )
+        to.write(f"    default:\n")
+        to.write(f"         {default_string};\n")
+        to.write(f"    }}\n")
 
-            self._generate_css_property_parsing_h_footing(
-                to=output_file
-            )
 
-    # MARK: - Helper generator functions for CSSPropertyParsing.cpp
+# Generation support for a properties fast path eligable keyword terms.
+class TermGeneratorFastPathKeywordTerms(TermGenerator):
+    def __init__(self, keyword_fast_path_generator):
+        self.keyword_fast_path_generator = keyword_fast_path_generator
+        self.requires_context = keyword_fast_path_generator.requires_context
 
-    def _generate_css_property_parsing_cpp_heading(self, *, to):
-        to.write(textwrap.dedent("""\
-            // This file is automatically generated from CSSProperties.json by the process-css-properties script. Do not edit it."
+    def generate_conditional(self, *, to, range_string, context_string):
+        to.write(f"    if (auto result = {self.generate_call_string(range_string=range_string, context_string=context_string)})\n")
+        to.write(f"         return result;\n")
 
-            #include "config.h"
-            #include "CSSPropertyParsing.h"
+    def generate_unconditional(self, *, to, range_string, context_string):
+        to.write(f"    return {self.generate_call_string(range_string=range_string, context_string=context_string)};\n")
 
-            #include "CSSParserContext.h"
-            #include "CSSParserIdioms.h"
-            #include "CSSPropertyParser.h"
-            #include "CSSPropertyParserWorkerSafe.h"
-            #include "CSSValuePool.h"
-            #include "DeprecatedGlobalSettings.h"
+    def generate_call_string(self, *, range_string, context_string):
+        # For root keyword terms we can utilize the `keyword-only fast path` function.
+        parameters = [range_string, self.keyword_fast_path_generator.generate_reference_string()]
+        if self.requires_context:
+            parameters.append(context_string)
+        return f"consumeIdent({', '.join(parameters)})"
 
-            namespace WebCore {
 
-            using namespace CSSPropertyParserHelpers;
-            using namespace CSSPropertyParserHelpersWorkerSafe;
+# Used by the `PropertyConsumer` classes to generate a `keyword-only fast path` function
+# (e.g. `isKeywordValidFor*`) for use both in the keyword only fast path and in the main
+# `parse` function.
+class KeywordFastPathGenerator:
+    def __init__(self, name, keyword_terms):
+        self.keyword_terms = keyword_terms
+        self.requires_context = any(keyword_term.requires_context for keyword_term in keyword_terms)
+        self.signature = KeywordFastPathGenerator._build_signature(name, self.requires_context)
 
-            """))
+    @staticmethod
+    def _build_parameters(requires_context):
+        parameters = [FunctionParameter("CSSValueID", "keyword")]
+        if requires_context:
+            parameters += [FunctionParameter("const CSSParserContext&", "context")]
+        return parameters
 
-    def _generate_css_property_parsing_cpp_footing(self, *, to):
-        to.write(textwrap.dedent("""\
-            } // namespace WebCore
-            """))
+    @staticmethod
+    def _build_signature(name, requires_context):
+        return FunctionSignature(
+            result_type="bool",
+            scope=None,
+            name=name,
+            parameters=KeywordFastPathGenerator._build_parameters(requires_context))
 
-    def _generate_css_property_parsing_cpp_is_keyword_valid_instance(self, *, to, property):
-        # FIXME: Consider ordering case statements by the CSSValueID's numeric value.
+    def generate_reference_string(self):
+        return self.signature.reference_string
 
-        parameters = ["CSSValueID keyword"]
-        if property.a_value_requires_a_settings_flag_or_is_internal:
-            parameters.append("const CSSParserContext& context")
+    def generate_call_string(self, *, keyword_string, context_string):
+        parameters = [keyword_string]
+        if self.requires_context:
+            parameters += [context_string]
 
-        to.write(f"\n")
-        to.write(f"static bool isKeywordValidFor{property.id_without_prefix}({', '.join(parameters)})\n")
+        return self.signature.generate_call_string(parameters)
+
+    def generate_definition(self, *, to):
+        to.write(f"static {self.signature.definition_string}\n")
         to.write(f"{{\n")
 
         # Build up a list of pairs of (value, return-expression-to-use-for-value), taking
         # into account settings flags and mode checks for internal values. Leave the return
         # expression as an empty array for the default return expression "return true;".
 
-        ValueReturnExpression = collections.namedtuple('ValueReturnExpression', ['value', 'return_expression'])
-        value_and_return_expressions = []
+        KeywordTermReturnExpression = collections.namedtuple('KeywordTermReturnExpression', ['keyword_term', 'return_expression'])
+        keyword_term_and_return_expressions = []
 
-        for value in property.values_sorted_by_name:
+        for keyword_term in self.keyword_terms:
             return_expression = []
-            if value.settings_flag:
-                if value.settings_flag.startswith("DeprecatedGlobalSettings::"):
-                    return_expression.append(value.settings_flag)
+            if keyword_term.settings_flag:
+                if keyword_term.settings_flag.startswith("DeprecatedGlobalSettings::"):
+                    return_expression.append(keyword_term.settings_flag)
                 else:
-                    return_expression.append(f"context.{value.settings_flag}")
-            if value.status == "internal":
+                    return_expression.append(f"context.{keyword_term.settings_flag}")
+            if keyword_term.status == "internal":
                 return_expression.append("isValueAllowedInMode(keyword, context.mode)")
 
-            value_and_return_expressions.append(ValueReturnExpression(value, return_expression))
+            keyword_term_and_return_expressions.append(KeywordTermReturnExpression(keyword_term, return_expression))
 
         # Take the list of pairs of (value, return-expression-to-use-for-value), and
         # group them by their 'return-expression' to avoid unnecessary duplication of
         # return statements.
         to.write(f"    switch (keyword) {{\n")
-        for return_expression, group in itertools.groupby(sorted(value_and_return_expressions, key=lambda x: x.return_expression), lambda x: x.return_expression):
-            for value, _ in group:
-                to.write(f"    case {value.id}:\n")
+        for return_expression, group in itertools.groupby(sorted(keyword_term_and_return_expressions, key=lambda x: x.return_expression), lambda x: x.return_expression):
+            for keyword_term, _ in group:
+                to.write(f"    case {keyword_term.value.id}:\n")
             to.write(f"        return {' && '.join(return_expression or ['true'])};\n")
 
         to.write(f"    default:\n")
         to.write(f"        return false;\n")
         to.write(f"    }}\n")
-        to.write(f"}}\n")
+        to.write(f"}}\n\n")
 
-    def _generate_css_property_parsing_cpp_is_keyword_valid_aggregate(self, *, to):
-        to.write(f"bool CSSPropertyParsing::isKeywordValidForProperty(CSSPropertyID id, CSSValueID keyword, const CSSParserContext& context)\n")
-        to.write(f"{{\n")
 
-        to.write(f"    switch (id) {{\n")
+# Each shared grammar rule has a corresponding `SharedGrammarRuleConsumer` which defines how
+# that rules parsing is exposed and if the parsing function for the rule should be exported in
+# the header for use in other areas of WebCore. Currently, all non-exported rules are 'skipped'
+# here. Note, that does not mean the rule isn't used, as a reference of that rule by a property
+# or another shared rule will still use the grammar, it will just be simplified into the parents
+# grammar with no explicit function being emitted. That leaves only exported rules actually
+# having functions emitted. The current set of kinds of `SharedGrammarRuleConsumer` are:
+#
+#   - `SkipSharedGrammarRuleConsumer`:
+#        Used when the shared property rule is not needed by other parts of WebCore, and therefore
+#        no explicit function needs to be emitted. Used for any shared rule that is not marked
+#        as 'exported`.
+#
+#   - `GeneratedSharedGrammarRuleConsumer`:
+#        Used for all exported rules. These generate a dedicated `consume` function which is exported
+#        in `CSSPropertyParser` for use by other parts of WebCore.
+#
+# `SharedGrammarRuleConsumer` abstract interface:
+#
+#   def generate_export_declaration(self, *, to):
+#   def generate_definition(self, *, to):
+#
+class SharedGrammarRuleConsumer(object):
+    @staticmethod
+    def make(shared_grammar_rule):
+        if not shared_grammar_rule.exported:
+            return SkipSharedGrammarRuleConsumer(shared_grammar_rule)
+        return GeneratedSharedGrammarRuleConsumer(shared_grammar_rule)
 
-        for property in self.properties.all_accepting_a_single_value_keyword:
-            to.write(f"    case {property.id}:\n")
 
-            # Call implementation of `isKeywordValidFor...` generated in `_generate_css_property_parsing_cpp_is_keyword_valid_instance`.
-            parameters = ["keyword"]
-            if property.a_value_requires_a_settings_flag_or_is_internal:
-                parameters.append("context")
-            to.write(f"        return isKeywordValidFor{property.id_without_prefix}({', '.join(parameters)});\n")
+class SkipSharedGrammarRuleConsumer(SharedGrammarRuleConsumer):
+    def __init__(self, shared_grammar_rule):
+        self.shared_grammar_rule = shared_grammar_rule
 
-        to.write(f"    default:\n")
-        to.write(f"        return false;\n")
-        to.write(f"    }}\n")
-        to.write(f"}}\n\n")
+    def __str__(self):
+        return "SkipSharedGrammarRuleConsumer"
 
-    def _generate_css_property_parsing_cpp_property_parsing_functions(self, *, to):
-        to.write(f"namespace {{\n")
+    def __repr__(self):
+        return self.__str__()
 
-        for property in self.properties.all_accepting_a_single_value_keyword:
-            self._generate_css_property_parsing_cpp_is_keyword_valid_instance(
-                to=to,
-                property=property
-            )
+    def generate_export_declaration(self, *, to):
+        pass
 
-        to.write(f"\n}} // namespace (anonymous)\n\n")
+    def generate_definition(self, *, to):
+        pass
 
-    def _generate_css_property_parsing_cpp_parse(self, *, to):
-        to.write(f"RefPtr<CSSValue> CSSPropertyParsing::parse(CSSParserTokenRange& range, CSSPropertyID id, CSSPropertyID currentShorthand, const CSSParserContext& context)\n")
+
+class GeneratedSharedGrammarRuleConsumer(SharedGrammarRuleConsumer):
+    def __init__(self, shared_grammar_rule):
+        self.term_generator = TermGenerator.make(shared_grammar_rule.grammar.root_term)
+        self.requires_context = self.term_generator.requires_context
+        self.signature = GeneratedSharedGrammarRuleConsumer._build_signature(shared_grammar_rule, self.requires_context)
+
+    def __str__(self):
+        return "GeneratedSharedGrammarRuleConsumer"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def _build_parameters(requires_context):
+        parameters = [FunctionParameter("CSSParserTokenRange&", "range")]
+        if requires_context:
+            parameters += [FunctionParameter("const CSSParserContext&", "context")]
+        return parameters
+
+    @staticmethod
+    def _build_signature(shared_grammar_rule, requires_context):
+        return FunctionSignature(
+            result_type="RefPtr<CSSValue>",
+            scope="CSSPropertyParsing",
+            name=f"consume{shared_grammar_rule.name_for_methods.id_without_prefix}",
+            parameters=GeneratedSharedGrammarRuleConsumer._build_parameters(requires_context))
+
+    def generate_export_declaration(self, *, to):
+        to.write(f"    static {self.signature.declaration_string};\n")
+
+    def generate_definition(self, *, to):
+        to.write(f"{self.signature.definition_string}\n")
         to.write(f"{{\n")
-        to.write(f"    if (!isExposed(id, context.propertySettings) && !isInternal(id)) {{\n")
-        to.write(f"        // Allow internal properties as we use them to parse several internal-only-shorthands (e.g. background-repeat),\n")
-        to.write(f"        // and to handle certain DOM-exposed values (e.g. -webkit-font-size-delta from execCommand('FontSizeDelta')).\n")
-        to.write(f"        ASSERT_NOT_REACHED();\n")
-        to.write(f"        return nullptr;\n")
-        to.write(f"    }}\n\n")
+        self.term_generator.generate_unconditional(to=to, range_string='range', context_string='context')
+        to.write(f"}}\n\n")
 
-        # Build up a list of pairs of (property, return-expression-to-use-for-property).
 
-        PropertyReturnExpression = collections.namedtuple('PropertyReturnExpression', ['property', 'return_expression'])
-        property_and_return_expressions = []
+# Each CSS property has a corresponding `PropertyConsumer` which defines how that property's
+# parsing works, if the parsing function for the property should be exported in the header for
+# use in other areas of WebCore, and what fast paths it exposes. The current set of kinds of
+# `PropertyConsumer` are:
+#
+#   - `SkipPropertyConsumer`:
+#        Used when the property is not eligable for parsing, and should be skipped. Used for
+#        descriptor-only properties, shorthand properties, and properties marked 'skip-parser`.
+#
+#   - `CustomPropertyConsumer`:
+#        Used when the property has been marked with `custom-parser` or `parser-function`. These
+#        property consumers never generate a `consume` function of their own, and call the defined
+#        `consume` function (either based on the property name if `custom-parser` or the one declared
+#        in `parser-function`) directly from the main `parse` function.
+#
+#   - `FastPathKeywordOnlyPropertyConsumer`:
+#        The only allowed values for this property are fast path eligible keyword values. These property
+#        consumers always emit a `keyword-only fast path` function (e.g. `isKeywordValidFor*`) and the
+#        main `parse` function uses that fast path function directly (e.g. `consumeIdent(range, isKeywordValidFor*)`
+#        This allows us to avoid making a `consume` function for the property in all cases except for
+#        when the property has been marked explicity with `parser-exported`, in which case we do
+#        generate a `consume` function to warp that invocation above.
+#
+#   - `DirectPropertyConsumer`:
+#        Used when a property's only term is a single non-simplifiable reference term (e.g. [ <number> ]
+#        or [ <color> ]. These property consumers call the referenced term directly from the main `parse`
+#        function. This allows us to avoid making a `consume` function for the property in all cases
+#        except for when the property has been marked explicity with `parser-exported`, in which case
+#        we do generate a `consume` function to warp that invocation above.
+#
+#   - `GeneratedPropertyConsumer`:
+#        Used for all other properties. Requires that `parser-grammar` has been defined. These property
+#        consumers use the provided parser grammer to generate a dedicated `consume` function which is
+#        called from the main `parse` function. If the parser grammar allows for any keyword only valid
+#        parses (e.g. for the grammar [ none | <image> ], "none" is a valid keyword only parse), these
+#        property consumers will also emit a `keyword-only fast path` function (e.g. `isKeywordValidFor*`)
+#        and ensure that it is called from the main `isKeywordValidForProperty` function.
+#
+# `PropertyConsumer` abstract interface:
+#
+#   def generate_call_string(self, *, range_string, id_string, current_shorthand_string, context_string):
+#   def generate_export_declaration(self, *, to):
+#   def generate_definition(self, *, to):
+#   var keyword_fast_path_generator
 
-        for property in self.properties.all:
-            if property.codegen_properties.longhands:
-                continue
-            if property.codegen_properties.descriptor_only:
-                continue
-            if property.codegen_properties.skip_parser:
-                continue
+class PropertyConsumer(object):
+    @staticmethod
+    def make(property):
+        if property.codegen_properties.longhands or property.codegen_properties.descriptor_only or property.codegen_properties.skip_parser:
+            return SkipPropertyConsumer(property)
 
-            if property.codegen_properties.custom_parser or property.codegen_properties.parser_function:
-                parameters = []
-                if property.codegen_properties.parser_requires_current_property:
-                    parameters.append("id")
-                parameters.append("range")
-                if property.codegen_properties.parser_requires_current_shorthand:
-                    parameters.append("currentShorthand")
-                if property.codegen_properties.parser_requires_context:
-                    parameters.append("context")
-                if property.codegen_properties.parser_requires_context_mode:
-                    parameters.append("context.mode")
-                if property.codegen_properties.parser_requires_quirks_mode:
-                    parameters.append("context.mode == HTMLQuirksMode")
-                if property.codegen_properties.parser_requires_value_pool:
-                    parameters.append("CSSValuePool::singleton()")
-                parameters += property.codegen_properties.parser_requires_additional_parameters
-
-                # If a "parser-function" has been specified, use that, otherwise assume the 'consume' function uses the property name.
-                function = property.codegen_properties.parser_function or f"consume{property.id_without_prefix}"
-
-                # Merge the scope, function and parameters to form the final invocation.
-                return_expression = f"{function}({', '.join(parameters)})"
-            elif property.accepts_a_single_value_keyword:
-                parameters = ["range", f"isKeywordValidFor{property.id_without_prefix}"]
-                if property.a_value_requires_a_settings_flag_or_is_internal:
-                    parameters.append("context")
-
-                return_expression = f"consumeIdent({', '.join(parameters)})"
-            else:
-                raise Exception(f"Invalid property definition for '{property.id}'. Style properties must either specify values or a custom parser.")
+        if property.codegen_properties.custom_parser or property.codegen_properties.parser_function:
+            return CustomPropertyConsumer(property)
 
-            property_and_return_expressions.append(PropertyReturnExpression(property, return_expression))
+        if property.codegen_properties.parser_grammar:
+            if property.codegen_properties.parser_grammar.has_only_fast_path_keyword_terms:
+                return FastPathKeywordOnlyPropertyConsumer(property)
+            if isinstance(property.codegen_properties.parser_grammar.root_term, ReferenceTerm):
+                return DirectPropertyConsumer(property)
+            return GeneratedPropertyConsumer(property)
 
-        # Take the list of pairs of (value, return-expression-to-use-for-value), and
-        # group them by their 'return-expression' to avoid unnecessary duplication of
-        # return statements.
+        if property.has_only_keyword_terms:
+            if property.has_only_fast_path_keyword_terms:
+                return FastPathKeywordOnlyPropertyConsumer(property)
+            return GeneratedPropertyConsumer(property)
 
-        PropertiesReturnExpression = collections.namedtuple('PropertiesReturnExpression', ['properties', 'return_expression'])
+        raise Exception(f"Invalid property definition for '{property.id}'. Style properties must either specify values or a custom parser.")
 
-        property_and_return_expressions_sorted_by_expression = sorted(property_and_return_expressions, key=lambda x: x.return_expression)
-        property_and_return_expressions_grouped_by_expression = []
-        for return_expression, group in itertools.groupby(property_and_return_expressions_sorted_by_expression, lambda x: x.return_expression):
-            properties = [property_and_return_expression.property for property_and_return_expression in group]
-            property_and_return_expressions_grouped_by_expression.append(PropertiesReturnExpression(properties, return_expression))
 
-        def _sort_by_first_property(a, b):
-            return Properties._sort_by_descending_priority_and_name(a.properties[0], b.properties[0])
+# Property consumer used for properties that should not be parsed.
+class SkipPropertyConsumer(PropertyConsumer):
+    def __init__(self, property):
+        self.property = property
 
-        to.write(f"    switch (id) {{\n")
-        for properties, return_expression in sorted(property_and_return_expressions_grouped_by_expression, key=functools.cmp_to_key(_sort_by_first_property)):
-            for property in properties:
-                to.write(f"    case {property.id}:\n")
-            to.write(f"        return {return_expression};\n")
+    def __str__(self):
+        return "SkipPropertyConsumer"
 
-        to.write(f"    default:\n")
-        to.write(f"        return nullptr;\n")
-        to.write(f"    }}\n")
-        to.write(f"}}\n\n")
+    def __repr__(self):
+        return self.__str__()
 
-    def generate_css_property_parsing_cpp(self):
-        with open('CSSPropertyParsing.cpp', 'w') as output_file:
-            self._generate_css_property_parsing_cpp_heading(
-                to=output_file
-            )
+    def generate_call_string(self, *, range_string, id_string, current_shorthand_string, context_string):
+        return None
 
-            self._generate_css_property_parsing_cpp_property_parsing_functions(
-                to=output_file
-            )
+    def generate_export_declaration(self, *, to):
+        pass
 
-            self._generate_css_property_parsing_cpp_parse(
-                to=output_file
-            )
+    def generate_definition(self, *, to):
+        pass
 
-            self._generate_css_property_parsing_cpp_is_keyword_valid_aggregate(
-                to=output_file
-            )
+    @property
+    def keyword_fast_path_generator(self):
+        return None
 
-            self._generate_property_id_switch_function_bool(
-                to=output_file,
-                signature="bool CSSPropertyParsing::isKeywordProperty(CSSPropertyID id)",
-                properties=self.properties.all_accepting_a_single_value_keyword,
-            )
 
-            self._generate_css_property_parsing_cpp_footing(
-                to=output_file
-            )
+# Property consumer used for properties with `custom-parser` or `parser-function` defined.
+class CustomPropertyConsumer(PropertyConsumer):
+    def __init__(self, property):
+        self.property = property
+
+    def __str__(self):
+        return "CustomPropertyConsumer"
+
+    def __repr__(self):
+        return self.__str__()
+
+    def generate_call_string(self, *, range_string, id_string, current_shorthand_string, context_string):
+        parameters = []
+        if self.property.codegen_properties.parser_requires_current_property:
+            parameters.append(id_string)
+        parameters.append(range_string)
+        if self.property.codegen_properties.parser_requires_current_shorthand:
+            parameters.append(current_shorthand_string)
+        if self.property.codegen_properties.parser_requires_context:
+            parameters.append(context_string)
+        if self.property.codegen_properties.parser_requires_context_mode:
+            parameters.append(f"{context_string}.mode")
+        if self.property.codegen_properties.parser_requires_quirks_mode:
+            parameters.append(f"{context_string}.mode == HTMLQuirksMode")
+        if self.property.codegen_properties.parser_requires_value_pool:
+            parameters.append("CSSValuePool::singleton()")
+        parameters += self.property.codegen_properties.parser_requires_additional_parameters
+
+        # If a "parser-function" has been specified, use that, otherwise assume the 'consume' function uses the property name.
+        function = self.property.codegen_properties.parser_function or f"consume{self.property.id_without_prefix}"
+
+        # Merge the scope, function and parameters to form the final invocation.
+        return f"{function}({', '.join(parameters)})"
+
+    def generate_export_declaration(self, *, to):
+        pass
+
+    def generate_definition(self, *, to):
+        pass
+
+    @property
+    def keyword_fast_path_generator(self):
+        return None
+
+
+# Property consumer used for properties with only fast-path eligable keyword terms in its grammar.
+class FastPathKeywordOnlyPropertyConsumer(PropertyConsumer):
+    def __init__(self, property):
+        self.property = property
+        self.keyword_fast_path_generator = KeywordFastPathGenerator(f"isKeywordValidFor{property.id_without_prefix}", property.fast_path_keyword_terms_sorted_by_name)
+        self.term_generator = TermGeneratorFastPathKeywordTerms(self.keyword_fast_path_generator)
+        self.signature = FastPathKeywordOnlyPropertyConsumer._build_signature(property, self.keyword_fast_path_generator)
+
+    def __str__(self):
+        return "FastPathKeywordOnlyPropertyConsumer"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def _build_scope(property):
+        if property.codegen_properties.parser_exported:
+            return "CSSPropertyParsing"
+        return None
+
+    @staticmethod
+    def _build_parameters(keyword_fast_path_generator):
+        parameters = [FunctionParameter("CSSParserTokenRange&", "range")]
+        if keyword_fast_path_generator.requires_context:
+            parameters += [FunctionParameter("const CSSParserContext&", "context")]
+        return parameters
+
+    @staticmethod
+    def _build_signature(property, keyword_fast_path_generator):
+        return FunctionSignature(
+            result_type="RefPtr<CSSValue>",
+            scope=FastPathKeywordOnlyPropertyConsumer._build_scope(property),
+            name=f"consume{property.id_without_prefix}",
+            parameters=FastPathKeywordOnlyPropertyConsumer._build_parameters(keyword_fast_path_generator))
+
+    def generate_call_string(self, *, range_string, id_string=None, current_shorthand_string=None, context_string):
+        # NOTE: Even in the case that we generate a `consume` function, we don't generate a call to it,
+        # but rather always directly use `consumeIdent` with the keyword-only fast path predicate.
+        return self.term_generator.generate_call_string(range_string=range_string, context_string=context_string)
+
+    # For "direct" and "fast-path keyword only" consumers, we only generate the property specific
+    # defintion if the property has been marked as exported.
+
+    def generate_export_declaration(self, *, to):
+        if self.property.codegen_properties.parser_exported:
+            to.write(f"    static {self.signature.declaration_string};\n")
+
+    def generate_definition(self, *, to):
+        if self.property.codegen_properties.parser_exported:
+            to.write(f"{self.signature.definition_string}\n")
+            to.write(f"{{\n")
+            to.write(f"    return {self.generate_call_string(range_string='range', context_string='context')};\n")
+            to.write(f"}}\n\n")
+
+
+# Property consumer for a property that has a `parser-grammar` that consists of only a single non-simplifiable
+# reference term (e.g. [ <number> ] or [ <color> ])
+class DirectPropertyConsumer(PropertyConsumer):
+    def __init__(self, property):
+        self.property = property
+        self.term_generator = TermGeneratorReferenceTerm(self.property.codegen_properties.parser_grammar.root_term)
+        self.signature = DirectPropertyConsumer._build_signature(self.property, self.term_generator)
+
+    def __str__(self):
+        return "DirectPropertyConsumer"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def _build_scope(property):
+        if property.codegen_properties.parser_exported:
+            return "CSSPropertyParsing"
+        return None
+
+    @staticmethod
+    def _build_parameters(term_generator):
+        parameters = [FunctionParameter("CSSParserTokenRange&", "range")]
+        if term_generator.requires_context:
+            parameters += [FunctionParameter("const CSSParserContext&", "context")]
+        return parameters
+
+    @staticmethod
+    def _build_signature(property, term_generator):
+        return FunctionSignature(
+            result_type="RefPtr<CSSValue>",
+            scope=DirectPropertyConsumer._build_scope(property),
+            name=f"consume{property.id_without_prefix}",
+            parameters=DirectPropertyConsumer._build_parameters(term_generator))
+
+    def generate_call_string(self, *, range_string, id_string=None, current_shorthand_string=None, context_string):
+        # NOTE: Even in the case that we generate a `consume` function for the case, we don't
+        # generate a call to it, but rather always generate the consume function for the reference,
+        # which is just as good and works in all cases.
+        return self.term_generator.generate_call_string(range_string=range_string, context_string=context_string)
+
+    # For "direct" and "fast-path keyword only" consumers, we only generate the property specific
+    # defintion if the property has been marked as exported.
+
+    def generate_export_declaration(self, *, to):
+        if self.property.codegen_properties.parser_exported:
+            to.write(f"    static {self.signature.declaration_string};\n")
+
+    def generate_definition(self, *, to):
+        if self.property.codegen_properties.parser_exported:
+            to.write(f"{self.signature.definition_string}\n")
+            to.write(f"{{\n")
+            self.term_generator.generate_unconditional(to=to, range_string='range', context_string='context')
+            to.write(f"}}\n\n")
+
+    @property
+    def keyword_fast_path_generator(self):
+        return None
+
+
+# Default property consumer. Uses `parser-grammar` to generate a `consume` function for the property.
+class GeneratedPropertyConsumer(PropertyConsumer):
+    def __init__(self, property):
+        self.property = property
+        self.keyword_fast_path_generator = GeneratedPropertyConsumer._build_keyword_fast_path_generator(property)
+        self.term_generator = TermGenerator.make(property.codegen_properties.parser_grammar.root_term, self.keyword_fast_path_generator)
+        self.requires_context = self.term_generator.requires_context
+        self.signature = GeneratedPropertyConsumer._build_signature(property, self.requires_context)
+
+    def __str__(self):
+        return "GeneratedPropertyConsumer"
+
+    def __repr__(self):
+        return self.__str__()
+
+    @staticmethod
+    def _build_scope(property):
+        if property.codegen_properties.parser_exported:
+            return "CSSPropertyParsing"
+        return None
+
+    @staticmethod
+    def _build_parameters(property, requires_context):
+        parameters = [FunctionParameter("CSSParserTokenRange&", "range")]
+        if requires_context:
+            parameters += [FunctionParameter("const CSSParserContext&", "context")]
+        return parameters
+
+    @staticmethod
+    def _build_signature(property, requires_context):
+        return FunctionSignature(
+            result_type="RefPtr<CSSValue>",
+            scope=GeneratedPropertyConsumer._build_scope(property),
+            name=f"consume{property.id_without_prefix}",
+            parameters=GeneratedPropertyConsumer._build_parameters(property, requires_context))
+
+    @staticmethod
+    def _build_keyword_fast_path_generator(property):
+        if property.has_fast_path_keyword_terms:
+            return KeywordFastPathGenerator(f"isKeywordValidFor{property.id_without_prefix}", property.fast_path_keyword_terms_sorted_by_name)
+        return None
+
+    def generate_call_string(self, *, range_string, id_string, current_shorthand_string, context_string):
+        parameters = [range_string]
+        if self.requires_context:
+            parameters += [context_string]
+        return self.signature.generate_call_string(parameters)
+
+    def generate_export_declaration(self, *, to):
+        if self.property.codegen_properties.parser_exported:
+            to.write(f"    static {self.signature.declaration_string};\n")
+
+    def generate_definition(self, *, to):
+        if self.property.codegen_properties.parser_exported:
+            to.write(f"{self.signature.definition_string}\n")
+        else:
+            to.write(f"static {self.signature.definition_string}\n")
+        to.write(f"{{\n")
+        self.term_generator.generate_unconditional(to=to, range_string='range', context_string='context')
+        to.write(f"}}\n\n")
+
 
 def main():
     parser = argparse.ArgumentParser(description='Process CSS property definitions.')
@@ -2544,26 +3940,25 @@ def main():
     with open(args.properties, "r") as properties_file:
         properties_json = json.load(properties_file)
 
-    parsing_context = ParsingContext(defines_string=args.defines, parsing_for_codegen=True, verbose=args.verbose)
-    properties = Properties.from_json(parsing_context, properties_json)
+    parsing_context = ParsingContext(properties_json, defines_string=args.defines, parsing_for_codegen=True, verbose=args.verbose)
+    parsing_context.parse_shared_grammar_rules()
+    parsing_context.parse_properties()
 
     if args.verbose:
-        print(f"{len(properties.properties)} properties active for code generation")
-
-    generation_context = GenerationContext(properties, verbose=args.verbose, gperf_executable=args.gperf_executable)
-
-    generation_context.generate_css_property_parsing_h()
-    generation_context.generate_css_property_parsing_cpp()
+        print(f"{len(parsing_context.parsed_properties.properties)} properties active for code generation")
 
-    generation_context.generate_css_property_names_h()
-    generation_context.generate_css_property_names_gperf()
-    generation_context.run_gperf()
+    generation_context = GenerationContext(parsing_context.parsed_properties, parsing_context.parsed_shared_grammar_rules, verbose=args.verbose, gperf_executable=args.gperf_executable)
 
-    generation_context.generate_css_style_declaration_property_names_idl()
+    generators = [
+        GenerateCSSPropertyNames,
+        GenerateCSSPropertyParsing,
+        GenerateCSSStyleDeclarationPropertyNames,
+        GenerateStyleBuilderGenerated,
+        GenerateStylePropertyShorthandFunctions,
+    ]
 
-    generation_context.generate_style_builder_generated_cpp()
-    generation_context.generate_style_property_shorthand_functions_h()
-    generation_context.generate_style_property_shorthand_functions_cpp()
+    for generator in generators:
+        generator(generation_context).generate()
 
 
 if __name__ == "__main__":
diff --git a/Tools/Scripts/webkitpy/style/checkers/jsonchecker.py b/Tools/Scripts/webkitpy/style/checkers/jsonchecker.py
index 1f78dda94195..c7cbd77164e2 100644
--- a/Tools/Scripts/webkitpy/style/checkers/jsonchecker.py
+++ b/Tools/Scripts/webkitpy/style/checkers/jsonchecker.py
@@ -25,7 +25,6 @@
 import json
 import re
 
-
 class JSONChecker(object):
     """Processes JSON lines for checking style."""
 
@@ -119,43 +118,82 @@ def check(self, lines):
 
         try:
             properties_definition = json.loads('\n'.join(lines) + '\n')
-            if 'properties' not in properties_definition:
-                self._handle_style_error(0, 'json/syntax', 5, '"properties" key not found, the key is mandatory.')
-                return
 
+            if 'categories' not in properties_definition:
+                self._handle_style_error(0, 'json/syntax', 5, '"categories" key not found, the key is mandatory.')
+                return
             self._categories = properties_definition['categories']
             self.check_categories()
 
-            properties = properties_definition['properties']
-            if not isinstance(properties, dict):
-                self._handle_style_error(0, 'json/syntax', 5, '"properties" is not a dictionary.')
+            if 'shared-grammar-rules' not in properties_definition:
+                self._handle_style_error(0, 'json/syntax', 5, '"shared-grammar-rules" key not found, the key is mandatory.')
                 return
+            self._shared_grammar_rules = properties_definition['shared-grammar-rules']
+            self.check_shared_grammar_rules()
 
-            for property_name, property_value in properties.items():
-                self.check_property(property_name, property_value)
+            if 'properties' not in properties_definition:
+                self._handle_style_error(0, 'json/syntax', 5, '"properties" key not found, the key is mandatory.')
+                return
+            self._properties = properties_definition['properties']
+            self.check_properties()
 
         except Exception as e:
             print(e)
             pass
 
-    def check_category(self, category, category_value):
+    def check_category(self, category_name, category_value):
         keys_and_validators = {
-            "shortname": self.validate_string,
-            "longname": self.validate_string,
-            "url": self.validate_url,
-            "status": self.validate_status_type,
+            'shortname': self.validate_string,
+            'longname': self.validate_string,
+            'url': self.validate_url,
+            'status': self.validate_status,
         }
         for key, value in category_value.items():
             if key not in keys_and_validators:
-                self._handle_style_error(0, 'json/syntax', 5, 'dictionary for specification "%s" has unexpected key "%s".' % (category, key))
+                self._handle_style_error(0, 'json/syntax', 5, 'dictionary for category "%s" has unexpected key "%s".' % (category_name, key))
                 return
 
-            keys_and_validators[key](category, "", key, value)
+            keys_and_validators[key](category_name, "", key, value)
 
     def check_categories(self):
+        if not isinstance(self._categories, dict):
+            self._handle_style_error(0, 'json/syntax', 5, '"categories" is not a dictionary.')
+            return
+
         for key, value in self._categories.items():
             self.check_category(key, value)
 
+    def check_shared_grammar_rule(self, rule_name, rule_value):
+        keys_and_validators = {
+            'comment': self.validate_comment,
+            'exported': self.validate_boolean,
+            'grammar': self.validate_grammar,
+            'specification': self.validate_specification,
+            'status': self.validate_status,
+        }
+        for key, value in rule_value.items():
+            if key not in keys_and_validators:
+                self._handle_style_error(0, 'json/syntax', 5, 'dictionary for shared property rule "%s" has unexpected key "%s".' % (rule_name, key))
+                return
+
+            keys_and_validators[key](rule_name, "", key, value)
+
+    def check_shared_grammar_rules(self):
+        if not isinstance(self._shared_grammar_rules, dict):
+            self._handle_style_error(0, 'json/syntax', 5, '"shared-grammar-rules" is not a dictionary.')
+            return
+
+        for rule_name, rule_value in self._shared_grammar_rules.items():
+            self.check_shared_grammar_rule(rule_name, rule_value)
+
+    def check_properties(self):
+        if not isinstance(self._properties, dict):
+            self._handle_style_error(0, 'json/syntax', 5, '"properties" is not a dictionary.')
+            return
+
+        for property_name, property_value in self._properties.items():
+            self.check_property(property_name, property_value)
+
     def validate_type(self, property_name, property_key, key, value, expected_type):
         if not isinstance(value, expected_type):
             self._handle_style_error(0, 'json/syntax', 5, '"%s" in "%s" %s is not of %s.' % (key, property_name, property_key, expected_type))
@@ -185,6 +223,7 @@ def validate_status_type(self, property_name, property_key, key, value):
             'not implemented',
             'not considering',
             'obsolete',
+            'removed',
         }
         if value not in allowed_statuses:
             self._handle_style_error(0, 'json/syntax', 5, 'status "%s" for property "%s" is not one of the recognized status values' % (value, property_name))
@@ -199,6 +238,33 @@ def validate_codegen_properties(self, property_name, property_key, key, value):
         else:
             self.check_codegen_properties(property_name, value)
 
+    def validate_grammar(self, property_name, property_key, key, value):
+        self.validate_grammar_term(property_name, property_key, key, value)
+
+    def validate_grammar_term(self, property_name, property_key, key, value):
+        if isinstance(value, dict):
+            keys_and_validators = {
+                'aliased-to': self.validate_string,
+                'comment': self.validate_comment,
+                'enable-if': self.validate_string,
+                'kind': self.validate_string,
+                'settings-flag': self.validate_string,
+                'status': self.validate_status,
+                'value': self.validate_grammar_term,
+            }
+
+            for key, value in value.items():
+                if key not in keys_and_validators:
+                    self._handle_style_error(0, 'json/syntax', 5, 'dictionary for "parser-grammar" of property "%s" has unexpected key "%s".' % (property_name, key))
+                    return
+
+                keys_and_validators[key](property_name, "", key, value)
+        elif isinstance(value, list):
+            for entry in value:
+                self.validate_grammar_term(property_name, "", "", entry)
+        else:
+            self.validate_string(property_name, property_key, key, value)
+
     def validate_logical_property_group(self, property_name, property_key, key, value):
         self.validate_type(property_name, property_key, key, value, dict)
 
@@ -224,7 +290,7 @@ def validate_status(self, property_name, property_key, key, value):
 
                 keys_and_validators[key](property_name, "", key, value)
         else:
-            self.validate_string(property_name, property_key, key, value)
+            self.validate_status_type(property_name, property_key, key, value)
 
     def validate_property_category(self, property_name, property_key, key, value):
         self.validate_string(property_name, property_key, key, value)
@@ -233,7 +299,7 @@ def validate_property_category(self, property_name, property_key, key, value):
             self._handle_style_error(0, 'json/syntax', 5, 'property "%s" has category "%s" which is not in the set of categories.' % (property_name, value))
             return
 
-    def validate_property_specification(self, property_name, property_key, key, value):
+    def validate_specification(self, property_name, property_key, key, value):
         self.validate_type(property_name, property_key, key, value, dict)
 
         keys_and_validators = {
@@ -265,7 +331,7 @@ def check_property(self, property_name, value):
             'values': self.validate_array,
             'codegen-properties': self.validate_codegen_properties,
             'status': self.validate_status,
-            'specification': self.validate_property_specification,
+            'specification': self.validate_specification,
         }
 
         for key, value in value.items():
@@ -303,6 +369,9 @@ def check_codegen_properties(self, property_name, codegen_properties):
             'logical-property-group': self.validate_logical_property_group,
             'longhands': self.validate_array,
             'name-for-methods': self.validate_string,
+            'parser-exported': self.validate_boolean,
+            'parser-grammar': self.validate_grammar,
+            'parser-grammar-comment': self.validate_comment,
             'parser-function': self.validate_string,
             'parser-requires-additional-parameters': self.validate_array,
             'parser-requires-context': self.validate_boolean,
@@ -311,7 +380,6 @@ def check_codegen_properties(self, property_name, codegen_properties):
             'parser-requires-current-property': self.validate_boolean,
             'parser-requires-quirks-mode': self.validate_boolean,
             'parser-requires-value-pool': self.validate_boolean,
-            'partial-keyword-property': self.validate_boolean,
             'no-default-color': self.validate_boolean,
             'related-property': self.validate_string,
             'runtime-flag': self.validate_string,