weasyprint 65.1__py3-none-any.whl → 67.0__py3-none-any.whl

weasyprint/css/{utils.py → tokens.py}

@@ -1,48 +1,19 @@
-"""Utils for CSS properties."""
+"""CSS tokens parsers."""
 
 import functools
-import math
 from abc import ABC, abstractmethod
-from urllib.parse import unquote, urljoin
+from math import e, inf, nan, pi
 
-from tinycss2.color4 import parse_color
+from tinycss2.ast import DimensionToken, IdentToken, NumberToken, PercentageToken
+from tinycss2.color5 import parse_color
 
-from .. import LOGGER
-from ..urls import iri_to_uri, url_is_absolute
+from ..logger import LOGGER
+from ..urls import get_url_tuple
+from . import functions
+from .functions import check_math
 from .properties import Dimension
+from .units import ANGLE_TO_RADIANS, LENGTH_UNITS, RESOLUTION_TO_DPPX
 
-# https://drafts.csswg.org/css-values-3/#angles
-# 1<unit> is this many radians.
-ANGLE_TO_RADIANS = {
-    'rad': 1,
-    'turn': 2 * math.pi,
-    'deg': math.pi / 180,
-    'grad': math.pi / 200,
-}
-
-# How many CSS pixels is one <unit>?
-# https://www.w3.org/TR/CSS21/syndata.html#length-units
-LENGTHS_TO_PIXELS = {
-    'px': 1,
-    'pt': 1. / 0.75,
-    'pc': 16.,  # LENGTHS_TO_PIXELS['pt'] * 12
-    'in': 96.,  # LENGTHS_TO_PIXELS['pt'] * 72
-    'cm': 96. / 2.54,  # LENGTHS_TO_PIXELS['in'] / 2.54
-    'mm': 96. / 25.4,  # LENGTHS_TO_PIXELS['in'] / 25.4
-    'q': 96. / 25.4 / 4,  # LENGTHS_TO_PIXELS['mm'] / 4
-}
-
-# https://drafts.csswg.org/css-values/#resolution
-RESOLUTION_TO_DPPX = {
-    'dppx': 1,
-    'dpi': 1 / LENGTHS_TO_PIXELS['in'],
-    'dpcm': 1 / LENGTHS_TO_PIXELS['cm'],
-}
-
-# Sets of possible length units
-LENGTH_UNITS = set(LENGTHS_TO_PIXELS) | set(['ex', 'em', 'ch', 'rem'])
-
-# Constants about background positions
 ZERO_PERCENT = Dimension(0, '%')
 FIFTY_PERCENT = Dimension(50, '%')
 HUNDRED_PERCENT = Dimension(100, '%')
@@ -54,14 +25,13 @@ BACKGROUND_POSITION_PERCENTAGES = {
     'right': HUNDRED_PERCENT,
 }
 
-# Direction keywords used for gradients
 DIRECTION_KEYWORDS = {
-    # ('angle', radians)  0 upwards, then clockwise
+    # ('angle', radians), 0 upwards, then clockwise.
     ('to', 'top'): ('angle', 0),
-    ('to', 'right'): ('angle', math.pi / 2),
-    ('to', 'bottom'): ('angle', math.pi),
-    ('to', 'left'): ('angle', math.pi * 3 / 2),
-    # ('corner', keyword)
+    ('to', 'right'): ('angle', pi / 2),
+    ('to', 'bottom'): ('angle', pi),
+    ('to', 'left'): ('angle', pi * 3 / 2),
+    # ('corner', keyword).
     ('to', 'top', 'left'): ('corner', 'top_left'),
     ('to', 'left', 'top'): ('corner', 'top_left'),
     ('to', 'top', 'right'): ('corner', 'top_right'),
@@ -72,29 +42,23 @@ DIRECTION_KEYWORDS = {
     ('to', 'right', 'bottom'): ('corner', 'bottom_right'),
 }
 
-# Default fallback values used in attr() functions
-ATTR_FALLBACKS = {
-    'string': ('string', ''),
-    'color': ('ident', 'currentcolor'),
-    'url': ('external', 'about:invalid'),
-    'integer': ('number', 0),
-    'number': ('number', 0),
-    '%': ('number', 0),
-}
-for unit in LENGTH_UNITS:
-    ATTR_FALLBACKS[unit] = ('length', Dimension('0', unit))
-for unit in ANGLE_TO_RADIANS:
-    ATTR_FALLBACKS[unit] = ('angle', Dimension('0', unit))
+E = NumberToken(0, 0, e, None, 'e')
+PI = NumberToken(0, 0, pi, None, 'π')
+PLUS_INFINITY = NumberToken(0, 0, inf, None, '∞')
+MINUS_INFINITY = NumberToken(0, 0, -inf, None, '-∞')
+NAN = NumberToken(0, 0, nan, None, 'NaN')
 
 
 class InvalidValues(ValueError):  # noqa: N818
     """Invalid or unsupported values for a known CSS property."""
 
 
-class CenterKeywordFakeToken:
-    type = 'ident'
-    lower_value = 'center'
-    unit = None
+class PercentageInMath(ValueError):  # noqa: N818
+    """Percentage in math function without reference length."""
+
+
+class FontUnitInMath(ValueError):  # noqa: N818
+    """Font-relative unit in math function without reference style."""
 
 
 class Pending(ABC):
@@ -118,136 +82,65 @@ class Pending(ABC):
                 # properties and expanders.
                 raise InvalidValues('no value')
             return self.validate(tokens, wanted_key)
-        except InvalidValues as exc:
+        except InvalidValues as exception:
             if self._reported_error:
-                raise exc
+                raise exception
             source_line = self.tokens[0].source_line
             source_column = self.tokens[0].source_column
             value = ' '.join(token.serialize() for token in tokens)
-            message = (exc.args and exc.args[0]) or 'invalid value'
+            message = exception.args[0] if exception.args else 'invalid value'
             LOGGER.warning(
                 'Ignored `%s: %s` at %d:%d, %s.',
                 self.name, value, source_line, source_column, message)
             self._reported_error = True
-            raise exc
-
-
-def split_on_comma(tokens):
-    """Split a list of tokens on commas, ie ``LiteralToken(',')``.
-
-    Only "top-level" comma tokens are splitting points, not commas inside a
-    function or blocks.
-
-    """
-    parts = []
-    this_part = []
-    for token in tokens:
-        if token.type == 'literal' and token.value == ',':
-            parts.append(this_part)
-            this_part = []
-        else:
-            this_part.append(token)
-    parts.append(this_part)
-    return tuple(parts)
-
-
-def split_on_optional_comma(tokens):
-    """Split a list of tokens on optional commas, ie ``LiteralToken(',')``."""
-    parts = []
-    for split_part in split_on_comma(tokens):
-        if not split_part:
-            # Happens when there's a comma at the beginning, at the end, or
-            # when two commas are next to each other.
-            return
-        for part in split_part:
-            parts.append(part)
-    return parts
-
-
-def remove_whitespace(tokens):
-    """Remove any top-level whitespace and comments in a token list."""
-    return tuple(
-        token for token in tokens
-        if token.type not in ('whitespace', 'comment'))
-
-
-def safe_urljoin(base_url, url):
-    if url_is_absolute(url):
-        return iri_to_uri(url)
-    elif base_url:
-        return iri_to_uri(urljoin(base_url, url))
-    else:
-        raise InvalidValues(
-            f'Relative URI reference without a base URI: {url!r}')
-
-
-def comma_separated_list(function):
-    """Decorator for validators that accept a comma separated list."""
-    @functools.wraps(function)
-    def wrapper(tokens, *args):
-        results = []
-        for part in split_on_comma(tokens):
-            result = function(remove_whitespace(part), *args)
-            if result is None:
-                return None
-            results.append(result)
-        return tuple(results)
-    wrapper.single_value = function
-    return wrapper
-
-
-def get_keyword(token):
-    """If ``token`` is a keyword, return its lowercase name.
-
-    Otherwise return ``None``.
-
-    """
-    if token.type == 'ident':
-        return token.lower_value
+            raise exception
 
 
-def get_custom_ident(token):
-    """If ``token`` is a keyword, return its name.
-
-    Otherwise return ``None``.
-
-    """
-    if token.type == 'ident':
-        return token.value
+def parse_color_hint(tokens):
+    if len(tokens) == 1:
+        return get_length(tokens[0], percentage=True)
 
 
-def get_single_keyword(tokens):
-    """If ``values`` is a 1-element list of keywords, return its name.
+def parse_color_stop(tokens):
+    if len(tokens) == 1:
+        color = parse_color(tokens[0])
+        if color == 'currentcolor':
+            # TODO: return the current color instead
+            return parse_color('black'), None
+        if color is not None:
+            return color, None
+    elif len(tokens) == 2:
+        color = parse_color(tokens[0])
+        position = get_length(tokens[1], negative=True, percentage=True)
+        if color is not None and position is not None:
+            return color, position
+    raise InvalidValues
 
-    Otherwise return ``None``.
 
-    """
-    if len(tokens) == 1:
-        token = tokens[0]
-        if token.type == 'ident':
-            return token.lower_value
+def parse_color_stops_and_hints(color_stops_hints):
+    if not color_stops_hints:
+        raise InvalidValues
 
+    color_stops = [parse_color_stop(color_stops_hints[0])]
+    color_hints = []
+    previous_was_color_stop = True
 
-def single_keyword(function):
-    """Decorator for validators that only accept a single keyword."""
-    @functools.wraps(function)
-    def keyword_validator(tokens):
-        """Wrap a validator to call get_single_keyword on tokens."""
-        keyword = get_single_keyword(tokens)
-        if function(keyword):
-            return keyword
-    return keyword_validator
+    for tokens in color_stops_hints[1:]:
+        if hint := parse_color_hint(tokens):
+            color_hints.append(hint)
+            previous_was_color_stop = False
+        elif previous_was_color_stop:
+            color_hints.append(FIFTY_PERCENT)
+            color_stops.append(parse_color_stop(tokens))
+            previous_was_color_stop = True
+        else:
+            color_stops.append(parse_color_stop(tokens))
+            previous_was_color_stop = True
 
+    if not previous_was_color_stop:
+        raise InvalidValues
 
-def single_token(function):
-    """Decorator for validators that only accept a single token."""
-    @functools.wraps(function)
-    def single_token_validator(tokens, *args):
-        """Validate a property whose token is single."""
-        if len(tokens) == 1:
-            return function(tokens[0], *args)
-    single_token_validator.__func__ = function
-    return single_token_validator
+    return color_stops, color_hints
 
 
 def parse_linear_gradient_parameters(arguments):
@@ -260,13 +153,13 @@ def parse_linear_gradient_parameters(arguments):
         result = DIRECTION_KEYWORDS.get(tuple(map(get_keyword, first_arg)))
         if result is not None:
             return result, arguments[1:]
-    return ('angle', math.pi), arguments  # Default direction is 'to bottom'
+    return ('angle', pi), arguments  # Default direction is 'to bottom'
 
 
 def parse_2d_position(tokens):
     """Common syntax of background-position and transform-origin."""
     if len(tokens) == 1:
-        tokens = [tokens[0], CenterKeywordFakeToken]
+        tokens = [tokens[0], IdentToken(0, 0, 'center')]
     elif len(tokens) != 2:
         return None
 
@@ -383,166 +276,93 @@ def parse_radial_gradient_parameters(arguments):
         arguments[1:])
 
 
-def parse_color_stop(tokens):
-    if len(tokens) == 1:
-        color = parse_color(tokens[0])
-        if color == 'currentcolor':
-            # TODO: return the current color instead
-            return parse_color('black'), None
-        if color is not None:
-            return color, None
-    elif len(tokens) == 2:
-        color = parse_color(tokens[0])
-        position = get_length(tokens[1], negative=True, percentage=True)
-        if color is not None and position is not None:
-            return color, position
-    raise InvalidValues
+def split_on_comma(tokens):
+    """Split a list of tokens on commas, ie ``LiteralToken(',')``.
 
+    Only "top-level" comma tokens are splitting points, not commas inside a
+    function or blocks.
 
-def parse_function(function_token):
-    """Parse functional notation.
+    """
+    parts = []
+    this_part = []
+    for token in tokens:
+        if token.type == 'literal' and token.value == ',':
+            parts.append(this_part)
+            this_part = []
+        else:
+            this_part.append(token)
+    parts.append(this_part)
+    return tuple(parts)
 
-    Return ``(name, args)`` if the given token is a function with comma- or
-    space-separated arguments. Return ``None`` otherwise.
 
-    """
-    if function_token.type != 'function':
-        return
+def remove_whitespace(tokens):
+    """Remove any top-level whitespace and comments in a token list."""
+    return tuple(
+        token for token in tokens
+        if token.type not in ('whitespace', 'comment'))
 
-    content = list(remove_whitespace(function_token.arguments))
-    arguments = []
-    last_is_comma = False
-    while content:
-        token = content.pop(0)
-        is_comma = token.type == 'literal' and token.value == ','
-        if last_is_comma and is_comma:
-            return
-        if is_comma:
-            last_is_comma = True
-        else:
-            last_is_comma = False
-            if token.type == 'function':
-                argument_function = parse_function(token)
-                if argument_function is None:
-                    return
-            arguments.append(token)
-    if last_is_comma:
-        return
-    return function_token.lower_name, arguments
 
+def get_keyword(token):
+    """If ``token`` is a keyword, return its lowercase name.
 
-def check_attr_function(token, allowed_type=None):
-    function = parse_function(token)
-    if function is None:
-        return
-    name, args = function
-    if name == 'attr' and len(args) in (1, 2, 3):
-        if args[0].type != 'ident':
-            return
-        attr_name = args[0].value
-        if len(args) == 1:
-            type_or_unit = 'string'
-            fallback = ''
-        else:
-            if args[1].type != 'ident':
-                return
-            type_or_unit = args[1].value
-            if type_or_unit not in ATTR_FALLBACKS:
-                return
-            if len(args) == 2:
-                fallback = ATTR_FALLBACKS[type_or_unit]
-            else:
-                fallback_type = args[2].type
-                if fallback_type == 'string':
-                    fallback = args[2].value
-                else:
-                    # TODO: handle other fallback types
-                    return
-        if allowed_type in (None, type_or_unit):
-            return ('attr()', (attr_name, type_or_unit, fallback))
+    Otherwise return ``None``.
 
+    """
+    if token.type == 'ident':
+        return token.lower_value
 
-def check_counter_function(token, allowed_type=None):
-    from .validation.properties import list_style_type
 
-    function = parse_function(token)
-    if function is None:
-        return
-    name, args = function
-    arguments = []
-    if (name == 'counter' and len(args) in (1, 2)) or (
-            name == 'counters' and len(args) in (2, 3)):
-        ident = args.pop(0)
-        if ident.type != 'ident':
-            return
-        arguments.append(ident.value)
+def get_custom_ident(token):
+    """If ``token`` is a keyword, return its name.
 
-        if name == 'counters':
-            string = args.pop(0)
-            if string.type != 'string':
-                return
-            arguments.append(string.value)
+    Otherwise return ``None``.
 
-        if args:
-            counter_style = list_style_type((args.pop(0),))
-            if counter_style is None:
-                return
-            arguments.append(counter_style)
-        else:
-            arguments.append('decimal')
+    """
+    if token.type == 'ident':
+        return token.value
 
-        return (f'{name}()', tuple(arguments))
 
+def get_single_keyword(tokens):
+    """If ``values`` is a 1-element list of keywords, return its name.
 
-def check_content_function(token):
-    function = parse_function(token)
-    if function is None:
-        return
-    name, args = function
-    if name == 'content':
-        if len(args) == 0:
-            return ('content()', 'text')
-        elif len(args) == 1:
-            ident = args.pop(0)
-            if ident.type == 'ident' and ident.lower_value in (
-                    'text', 'before', 'after', 'first-letter', 'marker'):
-                return ('content()', ident.lower_value)
-
-
-def check_string_or_element_function(string_or_element, token):
-    function = parse_function(token)
-    if function is None:
-        return
-    name, args = function
-    if name == string_or_element and len(args) in (1, 2):
-        custom_ident = args.pop(0)
-        if custom_ident.type != 'ident':
-            return
-        custom_ident = custom_ident.value
+    Otherwise return ``None``.
 
-        if args:
-            ident = args.pop(0)
-            if ident.type != 'ident' or ident.lower_value not in (
-                    'first', 'start', 'last', 'first-except'):
-                return
-            ident = ident.lower_value
-        else:
-            ident = 'first'
+    """
+    if len(tokens) == 1:
+        token = tokens[0]
+        if token.type == 'ident':
+            return token.lower_value
 
-        return (f'{string_or_element}()', (custom_ident, ident))
 
+def get_number(token, negative=True, integer=False):
+    """Parse a <number> token."""
+    from . import resolve_math
 
-def check_var_function(token):
-    if function := parse_function(token):
-        name, args = function
-        if name == 'var' and args:
-            ident = args.pop(0)
-            # TODO: we should check authorized tokens
-            # https://drafts.csswg.org/css-syntax-3/#typedef-declaration-value
-            return ident.type == 'ident' and ident.value.startswith('--')
-        for arg in args:
-            if check_var_function(arg):
-                return True
+    if check_math(token):
+        try:
+            resolved = resolve_math(token)
+        except (PercentageInMath, FontUnitInMath):
+            return
+        else:
+            if resolved is None:
+                return
+            if resolved.type != 'number':
+                return
+            value = resolved.value
+            if not negative and value < 0:
+                value = 0
+            if integer:
+                # TODO: always round x.5 to +inf, see
+                # https://drafts.csswg.org/css-values-4/#combine-integers.
+                value = round(value)
+            return Dimension(value, None)
+    elif token.type == 'number':
+        if integer:
+            if token.int_value is not None:
+                if negative or token.int_value >= 0:
+                    return Dimension(token.int_value, None)
+        elif negative or token.value >= 0:
+            return Dimension(token.value, None)
 
 
 def get_string(token):
@@ -551,39 +371,83 @@ def get_string(token):
         return ('string', token.value)
     if token.type == 'function':
         if token.name == 'attr':
-            return check_attr_function(token, 'string')
+            return functions.check_attr(token, 'string')
         elif token.name in ('counter', 'counters'):
-            return check_counter_function(token)
+            return functions.check_counter(token)
         elif token.name == 'content':
-            return check_content_function(token)
+            return functions.check_content(token)
         elif token.name == 'string':
-            return check_string_or_element_function('string', token)
+            return functions.check_string_or_element('string', token)
+
+
+def get_percentage(token, negative=True):
+    """Parse a <percentage> token."""
+    from . import resolve_math
+
+    if check_math(token):
+        try:
+            token = resolve_math(token) or token
+        except (PercentageInMath, FontUnitInMath):
+            return
+        else:
+            # Range clamp.
+            if not negative:
+                token.value = max(0, token.value)
+    if token.type == 'percentage' and (negative or token.value >= 0):
+        return Dimension(token.value, '%')
 
 
 def get_length(token, negative=True, percentage=False):
     """Parse a <length> token."""
+    from . import resolve_math
+
+    if check_math(token):
+        try:
+            token = resolve_math(token) or token
+        except PercentageInMath:
+            # PercentageInMath is raised in priority to help discarding percentages for
+            # properties that don’t allow them.
+            return token if percentage else None
+        except FontUnitInMath:
+            return token
+        else:
+            # Range clamp.
+            if not negative and token.type not in ('function', 'number'):
+                token.value = max(0, token.value)
     if percentage and token.type == 'percentage':
         if negative or token.value >= 0:
             return Dimension(token.value, '%')
-    if token.type == 'dimension' and token.unit in LENGTH_UNITS:
+    if token.type == 'dimension' and token.unit.lower() in LENGTH_UNITS:
         if negative or token.value >= 0:
-            return Dimension(token.value, token.unit)
+            return Dimension(token.value, token.unit.lower())
     if token.type == 'number' and token.value == 0:
         return Dimension(0, None)
 
 
 def get_angle(token):
     """Parse an <angle> token in radians."""
+    from . import resolve_math
+
+    try:
+        token = resolve_math(token) or token
+    except (PercentageInMath, FontUnitInMath):
+        return
     if token.type == 'dimension':
-        factor = ANGLE_TO_RADIANS.get(token.unit)
+        factor = ANGLE_TO_RADIANS.get(token.unit.lower())
         if factor is not None:
             return token.value * factor
 
 
 def get_resolution(token):
-    """Parse a <resolution> token in ddpx."""
+    """Parse a <resolution> token in dppx."""
+    from . import resolve_math
+
+    try:
+        token = resolve_math(token) or token
+    except (PercentageInMath, FontUnitInMath):
+        return
     if token.type == 'dimension':
-        factor = RESOLUTION_TO_DPPX.get(token.unit)
+        factor = RESOLUTION_TO_DPPX.get(token.unit.lower())
         if factor is not None:
             return token.value * factor
 
@@ -592,22 +456,21 @@ def get_image(token, base_url):
     """Parse an <image> token."""
     from ..images import LinearGradient, RadialGradient
 
-    parsed_url = get_url(token, base_url)
-    if parsed_url:
+    if parsed_url := get_url(token, base_url):
         assert parsed_url[0] == 'url'
         if parsed_url[1][0] == 'external':
             return 'url', parsed_url[1][1]
-    if token.type != 'function':
+    function = functions.Function(token)
+    arguments = function.split_comma(single_tokens=False)
+    if not arguments:
         return
-    arguments = split_on_comma(remove_whitespace(token.arguments))
-    name = token.lower_name
-    if name in ('linear-gradient', 'repeating-linear-gradient'):
+    repeating = function.name.startswith('repeating-')
+    if function.name in ('linear-gradient', 'repeating-linear-gradient'):
         direction, color_stops = parse_linear_gradient_parameters(arguments)
-        if color_stops:
-            return 'linear-gradient', LinearGradient(
-                [parse_color_stop(stop) for stop in color_stops],
-                direction, 'repeating' in name)
-    elif name in ('radial-gradient', 'repeating-radial-gradient'):
+        color_stops, color_hints = parse_color_stops_and_hints(color_stops)
+        return 'linear-gradient', LinearGradient(
+            color_stops, direction, repeating, color_hints)
+    elif function.name in ('radial-gradient', 'repeating-radial-gradient'):
         result = parse_radial_gradient_parameters(arguments)
         if result is not None:
             shape, size, position, color_stops = result
@@ -616,30 +479,31 @@ def get_image(token, base_url):
             size = 'keyword', 'farthest-corner'
             position = 'left', FIFTY_PERCENT, 'top', FIFTY_PERCENT
             color_stops = arguments
-        if color_stops:
-            return 'radial-gradient', RadialGradient(
-                [parse_color_stop(stop) for stop in color_stops],
-                shape, size, position, 'repeating' in name)
-
-
-def _get_url_tuple(string, base_url):
-    if string.startswith('#'):
-        return ('url', ('internal', unquote(string[1:])))
-    else:
-        return ('url', ('external', safe_urljoin(base_url, string)))
+        color_stops, color_hints = parse_color_stops_and_hints(color_stops)
+        return 'radial-gradient', RadialGradient(
+            color_stops, shape, size, position, repeating, color_hints)
 
 
 def get_url(token, base_url):
     """Parse an <url> token."""
     if token.type == 'url':
-        return _get_url_tuple(token.value, base_url)
+        url = get_url_tuple(token.value, base_url)
     elif token.type == 'function':
         if token.name == 'attr':
-            return check_attr_function(token, 'url')
+            return functions.check_attr(token, 'url')
         elif token.name == 'url' and len(token.arguments) in (1, 2):
             # Ignore url modifiers
             # See https://drafts.csswg.org/css-values-3/#urls
-            return _get_url_tuple(token.arguments[0].value, base_url)
+            url = get_url_tuple(token.arguments[0].value, base_url)
+        else:
+            return
+    else:
+        return
+
+    if url is None:
+        raise InvalidValues(f'Relative URI reference without a base URI: {url!r}')
+
+    return ('url', url)
 
 
 def get_quote(token):
@@ -653,29 +517,23 @@ def get_quote(token):
 
 def get_target(token, base_url):
     """Parse a <target> token."""
-    function = parse_function(token)
-    if function is None:
-        return
-    name, args = function
-    args = split_on_optional_comma(args)
-    if not args:
-        return
-
-    if name == 'target-counter':
-        if len(args) not in (2, 3):
+    function = functions.Function(token)
+    arguments = function.split_comma()
+    if function.name == 'target-counter':
+        if len(arguments) not in (2, 3):
             return
-    elif name == 'target-counters':
-        if len(args) not in (3, 4):
+    elif function.name == 'target-counters':
+        if len(arguments) not in (3, 4):
             return
-    elif name == 'target-text':
-        if len(args) not in (1, 2):
+    elif function.name == 'target-text':
+        if len(arguments) not in (1, 2):
             return
     else:
         return
 
     values = []
 
-    link = args.pop(0)
+    link = arguments.pop(0)
     string_link = get_string(link)
     if string_link is None:
         url = get_url(link, base_url)
@@ -685,54 +543,49 @@ def get_target(token, base_url):
     else:
         values.append(string_link)
 
-    if name.startswith('target-counter'):
-        if not args:
-            return
-
-        ident = args.pop(0)
+    if function.name.startswith('target-counter'):
+        ident = arguments.pop(0)
         if ident.type != 'ident':
             return
         values.append(ident.value)
 
-        if name == 'target-counters':
-            string = get_string(args.pop(0))
+        if function.name == 'target-counters':
+            string = get_string(arguments.pop(0))
             if string is None:
                 return
             values.append(string)
 
-        if args:
-            counter_style = get_keyword(args.pop(0))
+        if arguments:
+            counter_style = get_keyword(arguments.pop(0))
         else:
             counter_style = 'decimal'
         values.append(counter_style)
     else:
-        if args:
-            content = get_keyword(args.pop(0))
+        if arguments:
+            content = get_keyword(arguments.pop(0))
             if content not in ('content', 'before', 'after', 'first-letter'):
                 return
         else:
             content = 'content'
         values.append(content)
 
-    return (f'{name}()', tuple(values))
+    return (f'{function.name}()', tuple(values))
 
 
 def get_content_list(tokens, base_url):
     """Parse <content-list> tokens."""
     # See https://www.w3.org/TR/css-content-3/#typedef-content-list
-    parsed_tokens = [
-        get_content_list_token(token, base_url) for token in tokens]
+    parsed_tokens = [get_content_list_token(token, base_url) for token in tokens]
     if None not in parsed_tokens:
         return parsed_tokens
 
 
 def get_content_list_token(token, base_url):
     """Parse one of the <content-list> tokens."""
-    # See https://www.w3.org/TR/css-content-3/#typedef-content-list
+    # See https://drafts.csswg.org/css-content-3/#content-values.
 
     # <string>
-    string = get_string(token)
-    if string is not None:
+    if (string := get_string(token)) is not None:
         return string
 
     # contents
@@ -740,30 +593,25 @@ def get_content_list_token(token, base_url):
         return ('content()', 'text')
 
     # <uri>
-    url = get_url(token, base_url)
-    if url is not None:
+    if (url := get_url(token, base_url)) is not None:
         return url
 
     # <quote>
-    quote = get_quote(token)
-    if quote is not None:
+    if (quote := get_quote(token)) is not None:
         return ('quote', quote)
 
     # <target>
-    target = get_target(token, base_url)
-    if target is not None:
+    if (target := get_target(token, base_url)) is not None:
         return target
 
-    function = parse_function(token)
-    if function is None:
-        return
-    name, args = function
+    function = functions.Function(token)
+    arguments = function.split_comma()
 
     # <leader()>
-    if name == 'leader':
-        if len(args) != 1:
+    if function.name == 'leader':
+        if len(arguments) != 1:
             return
-        arg, = args
+        arg, = arguments
         if arg.type == 'ident':
             if arg.value == 'dotted':
                 string = '.'
@@ -778,5 +626,66 @@ def get_content_list_token(token, base_url):
         return ('leader()', ('string', string))
 
     # <element()>
-    elif name == 'element':
-        return check_string_or_element_function('element', token)
+    elif function.name == 'element':
+        return functions.check_string_or_element('element', token)
+
+
+def single_keyword(function):
+    """Decorator for validators that only accept a single keyword."""
+    @functools.wraps(function)
+    def keyword_validator(tokens):
+        """Wrap a validator to call get_single_keyword on tokens."""
+        keyword = get_single_keyword(tokens)
+        if function(keyword):
+            return keyword
+    return keyword_validator
+
+
+def single_token(function):
+    """Decorator for validators that only accept a single token."""
+    @functools.wraps(function)
+    def single_token_validator(tokens, *args):
+        """Validate a property whose token is single."""
+        if len(tokens) == 1:
+            return function(tokens[0], *args)
+    single_token_validator.__func__ = function
+    return single_token_validator
+
+
+def comma_separated_list(function):
+    """Decorator for validators that accept a comma separated list."""
+    @functools.wraps(function)
+    def wrapper(tokens, *args):
+        results = []
+        for part in split_on_comma(tokens):
+            result = function(remove_whitespace(part), *args)
+            if result is None:
+                return None
+            results.append(result)
+        return tuple(results)
+    wrapper.single_value = function
+    return wrapper
+
+
+def tokenize(item, function=None, unit=None):
+    """Transform a computed value result into a token."""
+    if isinstance(item, (DimensionToken, Dimension)):
+        value = function(item.value) if function else item.value
+        return DimensionToken(0, 0, value, None, str(value), item.unit.lower())
+    elif isinstance(item, PercentageToken):
+        value = function(item.value) if function else item.value
+        return PercentageToken(0, 0, value, None, str(value))
+    elif isinstance(item, (NumberToken, int, float)):
+        if isinstance(item, NumberToken):
+            value = item.value
+        else:
+            value = item
+        value = function(value) if function else value
+        int_value = round(value) if float(value).is_integer() else None
+        representation = str(int_value if float(value).is_integer() else value)
+        if unit is None:
+            return NumberToken(0, 0, value, int_value, representation)
+        elif unit == '%':
+            return PercentageToken(0, 0, value, int_value, representation)
+        else:
+            return DimensionToken(0, 0, value, int_value, representation, unit)