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

weasyprint/css/computed_values.py

@@ -1,16 +1,16 @@
 """Convert specified property values into computed values."""
 
 from math import pi
-from urllib.parse import unquote
 
-from tinycss2.color4 import parse_color
+from tinycss2.color5 import parse_color
 
 from ..logger import LOGGER
-from ..text.ffi import FROM_UNITS, ffi, pango
-from ..text.line_break import Layout, first_line_metrics
-from ..urls import get_link_attribute
+from ..text.line_break import strut
+from ..urls import get_link_attribute, get_url_tuple
+from .functions import check_math
 from .properties import INITIAL_VALUES, ZERO_PIXELS, Dimension
-from .utils import ANGLE_TO_RADIANS, LENGTH_UNITS, LENGTHS_TO_PIXELS, safe_urljoin
+from .units import ANGLE_TO_RADIANS, LENGTH_UNITS, to_pixels
+from .validation import validate_non_shorthand
 
 # Value in pixels of font-size for <absolute-size> keywords: 12pt (16px) for
 # medium, and scaling factors given in CSS3 for others:
@@ -122,35 +122,13 @@ assert all(width.value < height.value for width, height in PAGE_SIZES.values())
 
 INITIAL_PAGE_SIZE = PAGE_SIZES['a4']
 INITIAL_VALUES['size'] = tuple(
-    size.value * LENGTHS_TO_PIXELS[size.unit] for size in INITIAL_PAGE_SIZE)
+    to_pixels(size, None, 'size') for size in INITIAL_PAGE_SIZE)
 
 
 # Maps property names to functions returning the computed values
 COMPUTER_FUNCTIONS = {}
 
 
-def _font_style_cache_key(style, include_size=False):
-    key = str((
-        style['font_family'],
-        style['font_style'],
-        style['font_stretch'],
-        style['font_weight'],
-        style['font_variant_ligatures'],
-        style['font_variant_position'],
-        style['font_variant_caps'],
-        style['font_variant_numeric'],
-        style['font_variant_alternates'],
-        style['font_variant_east_asian'],
-        style['font_feature_settings'],
-        style['font_variation_settings'],
-        style['font_language_override'],
-        style['lang'],
-    ))
-    if include_size:
-        key += str(style['font_size']) + str(style['line_height'])
-    return key
-
-
 def register_computer(name):
     """Decorator registering a property ``name`` for a function."""
     name = name.replace('-', '_')
@@ -163,7 +141,8 @@ def register_computer(name):
 
 
 def compute_attr(style, values):
-    # TODO: use real token parsing instead of casting with Python types
+    # TODO: use real token parsing instead of casting with Python types, and follow new
+    # syntax. See https://drafts.csswg.org/css-values-5/#attr-notation.
     func_name, value = values
     assert func_name == 'attr()'
     attr_name, type_or_unit, fallback = value
@@ -172,13 +151,9 @@ def compute_attr(style, values):
         if type_or_unit == 'string':
             pass  # Keep the string
         elif type_or_unit == 'url':
-            if attr_value.startswith('#'):
-                attr_value = ('internal', unquote(attr_value[1:]))
-            else:
-                attr_value = (
-                    'external', safe_urljoin(style.base_url, attr_value))
+            attr_value = get_url_tuple(attr_value, style.base_url)
         elif type_or_unit == 'color':
-            attr_value = parse_color(attr_value.strip())
+            attr_value = parse_color(attr_value.strip(), style['color_scheme'])
         elif type_or_unit == 'integer':
             attr_value = int(attr_value.strip())
         elif type_or_unit == 'number':
@@ -192,6 +167,8 @@ def compute_attr(style, values):
         elif type_or_unit in ANGLE_TO_RADIANS:
             attr_value = Dimension(float(attr_value.strip()), type_or_unit)
             type_or_unit = 'angle'
+        else:
+            return
     except Exception:
         return
     return (type_or_unit, attr_value)
@@ -205,15 +182,30 @@ def background_image(style, name, values):
             value.stop_positions = tuple(
                 length(style, name, pos) if pos is not None else None
                 for pos in value.stop_positions)
+            value.color_hints = tuple(
+                length(style, name, hint) if hint is not None else None
+                for hint in value.color_hints)
         if type_ == 'radial-gradient':
             value.center, = compute_position(
                 style, name, (value.center,))
             if value.size_type == 'explicit':
-                value.size = length_or_percentage_tuple(
-                    style, name, value.size)
+                value.size = length_or_percentage_tuple(style, name, value.size)
     return values
 
 
+@register_computer('color')
+@register_computer('background-color')
+@register_computer('border-top-color')
+@register_computer('border-right-color')
+@register_computer('border-bottom-color')
+@register_computer('border-left-color')
+@register_computer('column-rule-color')
+@register_computer('outline-color')
+@register_computer('text-decoration-color')
+def color(style, name, values):
+    return parse_color(values, style['color_scheme'])
+
+
 @register_computer('background-position')
 @register_computer('object-position')
 def compute_position(style, name, values):
@@ -235,8 +227,7 @@ def length_or_percentage_tuple(style, name, values):
 @register_computer('clip')
 def length_tuple(style, name, values):
     """Compute the properties with a list of lengths."""
-    return tuple(
-        length(style, name, value, pixels_only=True) for value in values)
+    return tuple(length(style, name, value, pixels_only=True) for value in values)
 
 
 @register_computer('break-after')
@@ -271,36 +262,16 @@ def break_before_after(style, name, value):
 @register_computer('text-decoration-thickness')
 def length(style, name, value, font_size=None, pixels_only=False):
     """Compute a length ``value``."""
-    if value in ('auto', 'content', 'from-font'):
+    if value in ('auto', 'content', 'from-font') or check_math(value):
         return value
-    if value.value == 0:
+    elif value.value == 0:
         return 0 if pixels_only else ZERO_PIXELS
-
-    unit = value.unit
-    if unit == 'px':
-        return value.value if pixels_only else value
-    elif unit in LENGTHS_TO_PIXELS:
-        # Convert absolute lengths to pixels
-        result = value.value * LENGTHS_TO_PIXELS[unit]
-    elif unit in ('em', 'ex', 'ch', 'rem'):
-        if font_size is None:
-            font_size = style['font_size']
-        if unit == 'ex':
-            # TODO: use context to use @font-face fonts
-            ratio = character_ratio(style, 'x')
-            result = value.value * font_size * ratio
-        elif unit == 'ch':
-            ratio = character_ratio(style, '0')
-            result = value.value * font_size * ratio
-        elif unit == 'em':
-            result = value.value * font_size
-        elif unit == 'rem':
-            result = value.value * style.root_style['font_size']
-    else:
+    elif value.unit not in LENGTH_UNITS:
         # A percentage or 'auto': no conversion needed.
         return value
 
-    return result if pixels_only else Dimension(result, 'px')
+    pixels = to_pixels(value, style, name, font_size)
+    return pixels if pixels_only else Dimension(pixels, 'px')
 
 
 @register_computer('bleed-left')
@@ -310,16 +281,14 @@ def length(style, name, value, font_size=None, pixels_only=False):
 def bleed(style, name, value):
     if value == 'auto':
         return Dimension(8 if 'crop' in style['marks'] else 0, 'px')
-    else:
-        return length(style, name, value)
+    return length(style, name, value)
 
 
 @register_computer('letter-spacing')
 def pixel_length(style, name, value):
     if value == 'normal':
         return value
-    else:
-        return length(style, name, value, pixels_only=True)
+    return length(style, name, value, pixels_only=True)
 
 
 @register_computer('background-size')
@@ -450,9 +419,7 @@ def border_radius(style, name, values):
 @register_computer('row-gap')
 def gap(style, name, value):
     """Compute the ``*-gap`` properties."""
-    if value == 'normal':
-        return value
-    return length(style, name, value)
+    return value if value == 'normal' else length(style, name, value)
 
 
 def _content_list(style, values):
@@ -478,7 +445,7 @@ def _content_list(style, values):
                 if attr is None:
                     computed_value = None
                 else:
-                    computed_value = (value[0], ((attr,) + value[1][1:]))
+                    computed_value = (value[0], (attr, *value[1][1:]))
             else:
                 computed_value = value
         if computed_value is None:
@@ -523,8 +490,7 @@ def display(style, name, value):
     # See https://www.w3.org/TR/CSS21/visuren.html#dis-pos-flo.
     float_ = style.specified['float']
     position = style.specified['position']
-    if position in ('absolute', 'fixed') or float_ != 'none' or (
-            style.is_root_element):
+    if position in ('absolute', 'fixed') or float_ != 'none' or style.is_root_element:
         if value == ('inline-table',):
             return ('block', 'table')
         elif len(value) == 1 and value[0].startswith('table-'):
@@ -572,7 +538,7 @@ def font_size(style, name, value):
                 return keyword_values[-i - 1]
         else:
             return parent_font_size * 0.8
-    elif value.unit == '%':
+    elif isinstance(value, Dimension) and value.unit == '%':
         return value.value * parent_font_size / 100
     else:
         return length(
@@ -602,7 +568,7 @@ def _compute_track_breadth(style, name, value):
     if value in ('auto', 'min-content', 'max-content'):
         return value
     elif isinstance(value, Dimension):
-        if value.unit == 'fr':
+        if value.unit and value.unit.lower() == 'fr':
             return value
         else:
             return length(style, name, value)
@@ -692,26 +658,23 @@ def anchor(style, name, values):
 def link(style, name, values):
     """Compute the ``link`` property."""
     if values == 'none':
-        return None
-    else:
-        type_, value = values
-        if type_ == 'attr()':
-            return get_link_attribute(style.element, value, style.base_url)
-        else:
-            return values
+        return
+    type_, value = values
+    if type_ == 'attr()':
+        return get_link_attribute(style.element, value, style.base_url)
+    return values
 
 
 @register_computer('lang')
 def lang(style, name, values):
     """Compute the ``lang`` property."""
     if values == 'none':
-        return None
-    else:
-        name, key = values
-        if name == 'attr()':
-            return style.element.get(key) or None
-        elif name == 'string':
-            return key
+        return
+    name, key = values
+    if name == 'attr()':
+        return style.element.get(key) or None
+    elif name == 'string':
+        return key
 
 
 @register_computer('tab-size')
@@ -734,17 +697,24 @@ def transform(style, name, value):
 @register_computer('vertical-align')
 def vertical_align(style, name, value):
     """Compute the ``vertical-align`` property."""
+    from ..css import resolve_math
+
     # Use +/- half an em for super and sub, same as Pango.
     # (See the SUPERSUB_RISE constant in pango-markup.c)
-    if value in (
-            'baseline', 'middle', 'text-top', 'text-bottom', 'top', 'bottom'):
+    if check_math(value):
+        height, _ = strut(style)
+        result = resolve_math(value, style, 'vertical_align', height)
+        value = validate_non_shorthand((result,), 'vertical-align')[0][1]
+        if value is None:
+            value = 'baseline'
+    if value in ('baseline', 'middle', 'text-top', 'text-bottom', 'top', 'bottom'):
         return value
     elif value == 'super':
         return style['font_size'] * 0.5
     elif value == 'sub':
         return style['font_size'] * -0.5
     elif value.unit == '%':
-        height, _ = strut_layout(style)
+        height, _ = strut(style)
         return height * value.value / 100
     else:
         return length(style, name, value, pixels_only=True)
@@ -753,79 +723,4 @@ def vertical_align(style, name, value):
 @register_computer('word-spacing')
 def word_spacing(style, name, value):
     """Compute the ``word-spacing`` property."""
-    if value == 'normal':
-        return 0
-    else:
-        return length(style, name, value, pixels_only=True)
-
-
-def strut_layout(style, context=None):
-    """Return a tuple of the used value of ``line-height`` and the baseline.
-
-    The baseline is given from the top edge of line height.
-
-    """
-    if style['font_size'] == 0:
-        return 0, 0
-
-    if context:
-        key = _font_style_cache_key(style, include_size=True)
-        if key in context.strut_layouts:
-            return context.strut_layouts[key]
-
-    layout = Layout(context, style)
-    layout.set_text(' ')
-    line, _ = layout.get_first_line()
-    _, _, _, _, text_height, baseline = first_line_metrics(
-        line, '', layout, resume_at=None, space_collapse=False, style=style)
-    if style['line_height'] == 'normal':
-        result = text_height, baseline
-        if context:
-            context.strut_layouts[key] = result
-        return result
-    type_, line_height = style['line_height']
-    if type_ == 'NUMBER':
-        line_height *= style['font_size']
-    result = line_height, baseline + (line_height - text_height) / 2
-    if context:
-        context.strut_layouts[key] = result
-    return result
-
-
-def character_ratio(style, character):
-    """Return the ratio of 1ex/font_size or 1ch/font_size."""
-    # TODO: use context to use @font-face fonts
-
-    assert character in ('x', '0')
-
-    cache = style.cache[f'ratio_{"ex" if character == "x" else "ch"}']
-    cache_key = _font_style_cache_key(style)
-    if cache_key in cache:
-        return cache[cache_key]
-
-    # Avoid recursion for letter-spacing and word-spacing properties
-    style = style.copy()
-    style['letter_spacing'] = 'normal'
-    style['word_spacing'] = 0
-    # Random big value
-    style['font_size'] = 1000
-
-    layout = Layout(context=None, style=style)
-    layout.set_text(character)
-    line, _ = layout.get_first_line()
-
-    ink_extents = ffi.new('PangoRectangle *')
-    logical_extents = ffi.new('PangoRectangle *')
-    pango.pango_layout_line_get_extents(line, ink_extents, logical_extents)
-    if character == 'x':
-        measure = -ink_extents.y * FROM_UNITS
-    else:
-        measure = logical_extents.width * FROM_UNITS
-    ffi.release(ink_extents)
-    ffi.release(logical_extents)
-
-    # Zero means some kind of failure, fallback is 0.5.
-    # We round to try keeping exact values that were altered by Pango.
-    ratio = round(measure / style['font_size'], 5) or 0.5
-    cache[cache_key] = ratio
-    return ratio
+    return 0 if value == 'normal' else length(style, name, value, pixels_only=True)

weasyprint/css/counters.py

@@ -7,7 +7,7 @@ https://www.w3.org/TR/css-counter-styles-3/#counter-style-system
 
 from math import inf
 
-from .utils import remove_whitespace
+from .tokens import remove_whitespace
 
 
 def symbol(string_or_url):

weasyprint/css/functions.py

@@ -0,0 +1,206 @@
+"""CSS functions parsers."""
+
+
+class Function:
+    """CSS function."""
+    # See https://drafts.csswg.org/css-values-4/#functional-notation.
+
+    def __init__(self, token):
+        """Create Function from function token."""
+        if getattr(token, 'type', None) == 'function':
+            self.name = token.lower_name
+            self.arguments = token.arguments
+        else:
+            self.name = self.arguments = None
+
+    def split_space(self):
+        """Split arguments on spaces."""
+        if self.arguments is not None:
+            return [
+                argument for argument in self.arguments
+                if argument.type not in ('whitespace', 'comment')]
+
+    def split_comma(self, single_tokens=True, trailing=False):
+        """Split arguments on commas.
+
+        Spaces in parentheses and after commas are removed.
+
+        If ``single_tokens`` is ``True``, check that only a single token is between
+        commas and flatten returned list.
+
+        If ``trailing`` is ``True``, allow a bare comma at the end.
+
+        """
+        if self.arguments is None:
+            return
+
+        parts = [[]]
+        for token in self.arguments:
+            if token.type == 'literal' and token.value == ',':
+                parts.append([])
+                continue
+            if token.type not in ('comment', 'whitespace'):
+                parts[-1].append(token)
+
+        if trailing:
+            if single_tokens:
+                if all(len(part) == 1 for part in parts[:-1]):
+                    if len(parts[-1]) in (0, 1):
+                        return [part[0] if part else None for part in parts[:-1]]
+            elif all(parts[:-1]):
+                return parts
+        else:
+            if single_tokens:
+                if all(len(part) == 1 for part in parts):
+                    return [part[0] for part in parts]
+            elif all(parts):
+                return parts
+        return []
+
+
+def check_attr(token, allowed_type=None):
+    function = Function(token)
+    if function.name != 'attr':
+        return
+
+    parts = function.split_comma(single_tokens=False, trailing=True)
+    if len(parts) == 1:
+        name_and_type, fallback = parts[0], ''
+    elif len(parts) == 2:
+        name_and_type, fallback = parts
+    else:
+        return
+
+    if any(token.type != 'ident' for token in name_and_type):
+        return
+    # TODO: follow new syntax, see https://drafts.csswg.org/css-values-5/#attr-notation.
+
+    name = name_and_type[0].value
+    type_or_unit = name_and_type[1].value if len(name_and_type) == 2 else 'string'
+    if allowed_type in (None, type_or_unit):
+        return ('attr()', (name, type_or_unit, fallback))
+
+
+def check_counter(token, allowed_type=None):
+    from .validation.properties import list_style_type
+
+    function = Function(token)
+    arguments = function.split_comma()
+    if function.name == 'counter':
+        if len(arguments) not in (1, 2):
+            return
+    elif function.name == 'counters':
+        if len(arguments) not in (2, 3):
+            return
+    else:
+        return
+
+    result = []
+    ident = arguments.pop(0)
+    if ident.type != 'ident':
+        return
+    result.append(ident.value)
+
+    if function.name == 'counters':
+        string = arguments.pop(0)
+        if string.type != 'string':
+            return
+        result.append(string.value)
+
+    if arguments:
+        counter_style = list_style_type((arguments.pop(0),))
+        if counter_style is None:
+            return
+        result.append(counter_style)
+    else:
+        result.append('decimal')
+
+    return (f'{function.name}()', tuple(result))
+
+
+def check_content(token):
+    function = Function(token)
+    if function.name == 'content':
+        arguments = function.split_comma()
+        if len(arguments) == 0:
+            return ('content()', 'text')
+        elif len(arguments) == 1:
+            ident = arguments.pop(0)
+            values = ('text', 'before', 'after', 'first-letter', 'marker')
+            if ident.type == 'ident' and ident.lower_value in values:
+                return ('content()', ident.lower_value)
+
+
+def check_string_or_element(string_or_element, token):
+    function = Function(token)
+    arguments = function.split_comma()
+    if function.name == string_or_element and len(arguments) in (1, 2):
+        custom_ident = arguments.pop(0)
+        if custom_ident.type != 'ident':
+            return
+        custom_ident = custom_ident.value
+
+        if arguments:
+            ident = arguments.pop(0)
+            if ident.type != 'ident':
+                return
+            if ident.lower_value not in ('first', 'start', 'last', 'first-except'):
+                return
+            ident = ident.lower_value
+        else:
+            ident = 'first'
+
+        return (f'{string_or_element}()', (custom_ident, ident))
+
+
+def check_var(token):
+    if token.type == '() block':
+        return any(check_var(item) for item in token.content)
+    function = Function(token)
+    if function.name is None:
+        return
+    arguments = function.split_space()
+    if function.name == 'var':
+        ident = arguments[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('--')
+    return any(check_var(argument) for argument in arguments)
+
+
+def check_math(token):
+    # TODO: validate for real.
+    function = Function(token)
+    if (name := function.name) is None:
+        return
+    arguments = function.split_comma(single_tokens=False)
+    if name == 'calc':
+        return len(arguments) == 1
+    elif name in ('min', 'max'):
+        return len(arguments) >= 1
+    elif name == 'clamp':
+        return len(arguments) == 3
+    elif name == 'round':
+        return 1 <= len(arguments) <= 3
+    elif name in ('mod', 'rem'):
+        return len(arguments) == 2
+    elif name in ('sin', 'cos', 'tan'):
+        return len(arguments) == 1
+    elif name in ('asin', 'acos', 'atan'):
+        return len(arguments) == 1
+    elif name == 'atan2':
+        return len(arguments) == 2
+    elif name == 'pow':
+        return len(arguments) == 2
+    elif name == 'sqrt':
+        return len(arguments) == 1
+    elif name == 'hypot':
+        return len(arguments) >= 1
+    elif name == 'log':
+        return 1 <= len(arguments) <= 2
+    elif name == 'exp':
+        return len(arguments) == 1
+    elif name in ('abs', 'sign'):
+        return len(arguments) == 1
+    arguments = function.split_space()
+    return any(check_math(argument) for argument in arguments)

weasyprint/css/html5_ua.css

@@ -47,11 +47,6 @@ h3 { margin-top: 1em; margin-bottom: 1em }
 h4 { margin-top: 1.33em; margin-bottom: 1.33em }
 h5 { margin-top: 1.67em; margin-bottom: 1.67em }
 h6 { margin-top: 2.33em; margin-bottom: 2.33em }
-:is(article, aside, nav, section) h1 { font-size: 1.5em; margin-bottom: .83em; margin-top: .83em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: 1.17em; margin-bottom: 1em; margin-top: 1em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: 1em; margin-bottom: 1.33em; margin-top: 1.33em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: .83em; margin-bottom: 1.67em; margin-top: 1.67em }
-:is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) :is(article, aside, nav, section) h1 { font-size: .67em; margin-bottom: 2.33em; margin-top: 2.33em }
 
 blockquote, figure { margin-left: 40px; margin-right: 40px }
 
@@ -87,6 +82,7 @@ sup { vertical-align: super }
 
 /* Fonts and colors */
 
+html { color-scheme: light }
 address, cite, dfn, em, i, var { font-style: italic }
 b, strong, th { font-weight: bold }
 code, kbd, listing, plaintext, pre, samp, tt, xmp { font-family: monospace }
@@ -174,9 +170,9 @@ input:is([type=button i], [type=reset i], [type=submit i])[value], button[value]
 input[type=submit i]:not([value])::before { content: "Submit" }
 input[type=reset i]:not([value])::before { content: "Reset" }
 input:is([type=checkbox i], [type=radio i]) { height: .7em; vertical-align: -.2em; width: .7em }
-input:is([type=checkbox i], [type=radio i])[checked]::before { background: black; content: ""; height: 100% }
+input:is([type=checkbox i], [type=radio i])[checked]::before { background: black; content: ""; display: block; height: 100% }
 input[type=radio i], input[type=radio][checked]:before { border-radius: 50% }
-input[value]::before { content: attr(value); display: block; overflow: hidden }
+input[value]:not([type=checkbox i], [type=radio i])::before { content: attr(value); display: block; overflow: hidden }
 :is(input, input[value=""], input[type=checkbox i], input[type=radio i]) { content: ""; display: block }
 select { background: lightgrey; border-radius: .25em .25em; position: relative; white-space: normal }
 select[multiple] { height: 3.6em }

weasyprint/css/html5_ua_form.css

@@ -1,5 +1,5 @@
 /* Default stylesheet for PDF forms */
 
 button, input, select, textarea { appearance: auto }
-select option, select:not([multiple])::before, input:not([type="submit"])::before {visibility: hidden }
-textarea { text-indent: 10000% } /* Hide text but don’t change color used by PDF form */
+select option, select:not([multiple])::before, input:not([type="submit"])::before { visibility: hidden }
+textarea { white-space: normal; text-indent: 10000% } /* Hide text but don’t change color used by PDF form */

weasyprint/css/media_queries.py

@@ -7,7 +7,7 @@ https://www.w3.org/TR/mediaqueries-4/
 import tinycss2
 
 from ..logger import LOGGER
-from .utils import remove_whitespace, split_on_comma
+from .tokens import remove_whitespace, split_on_comma
 
 
 def evaluate_media_query(query_list, device_media_type):
@@ -28,6 +28,8 @@ def parse_media_query(tokens):
         return ['all']
     else:
         media = []
+        if tokens[0].type == 'ident' and tokens[0].lower_value == 'only':
+            tokens = tokens[1:]
         for part in split_on_comma(tokens):
             types = [token.type for token in part]
             if types == ['ident']: