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

weasyprint/layout/inline.py

@@ -3,25 +3,27 @@
 import unicodedata
 from math import inf
 
-from ..css import computed_from_cascaded
-from ..css.computed_values import character_ratio, strut_layout
+from ..css import Pending
+from ..css.properties import INHERITED
 from ..formatting_structure import boxes, build
-from ..text.line_break import can_break_text, create_layout, split_first_line
 from .absolute import AbsolutePlaceholder, absolute_layout
 from .flex import flex_layout
 from .float import avoid_collisions, float_layout
 from .grid import grid_layout
 from .leader import handle_leader
 from .min_max import handle_min_max_width
-from .percent import resolve_one_percentage, resolve_percentages
+from .percent import percentage, resolve_one_percentage, resolve_percentages
 from .preferred import inline_min_content_width, shrink_to_fit, trailing_whitespace_size
 from .replaced import inline_replaced_box_layout
 from .table import find_in_flow_baseline, table_wrapper_width
 
+from ..text.line_break import (  # isort:skip
+    can_break_text, character_ratio, create_layout, split_first_line, strut)
+
 
 def iter_line_boxes(context, box, position_y, bottom_space, skip_stack,
                     containing_block, absolute_boxes, fixed_boxes,
-                    first_letter_style):
+                    first_letter_style, first_line_style):
     """Return an iterator of ``(line, resume_at)``.
 
     ``line`` is a laid-out LineBox with as much content as possible that
@@ -30,14 +32,15 @@ def iter_line_boxes(context, box, position_y, bottom_space, skip_stack,
     """
     resolve_percentages(box, containing_block)
     if skip_stack is None:
-        # TODO: wrong, see https://github.com/Kozea/WeasyPrint/issues/679
+        # TODO: wrong, see issue #679.
         resolve_one_percentage(box, 'text_indent', containing_block.width)
     else:
         box.text_indent = 0
     while True:
         line, resume_at = get_next_linebox(
-            context, box, position_y, bottom_space, skip_stack,
-            containing_block, absolute_boxes, fixed_boxes, first_letter_style)
+            context, box, position_y, bottom_space, skip_stack, containing_block,
+            absolute_boxes, fixed_boxes, first_letter_style, first_line_style)
+        first_line_style = None
         if line:
             handle_leader(context, line, containing_block)
             position_y = line.position_y + line.height
@@ -53,8 +56,16 @@ def iter_line_boxes(context, box, position_y, bottom_space, skip_stack,
 
 def get_next_linebox(context, linebox, position_y, bottom_space, skip_stack,
                      containing_block, absolute_boxes, fixed_boxes,
-                     first_letter_style):
-    """Return ``(line, resume_at)``."""
+                     first_letter_style, first_line_style):
+    """Return next line from given linebox.
+
+    Return ``(line, resume_at)``, where ``line`` is a new linebox copied from the
+    original one, with replaced children.
+
+    This function takes care of excluded floating shapes to avoid collisions.
+
+    """
+
     skip_stack = skip_first_whitespace(linebox, skip_stack)
     if skip_stack == 'continue':
         return None, None
@@ -67,7 +78,7 @@ def get_next_linebox(context, linebox, position_y, bottom_space, skip_stack,
         # Width and height must be calculated to avoid floats
         linebox.width = inline_min_content_width(
             context, linebox, skip_stack=skip_stack, first_line=True)
-        linebox.height, _ = strut_layout(linebox.style, context)
+        linebox.height, _ = strut(linebox.style)
     else:
         # No float, width and height will be set by the lines
         linebox.width = linebox.height = 0
@@ -95,7 +106,7 @@ def get_next_linebox(context, linebox, position_y, bottom_space, skip_stack,
          last_letter, float_width) = split_inline_box(
              context, linebox, position_x, max_x, bottom_space, skip_stack,
              containing_block, line_absolutes, line_fixed, line_placeholders,
-             waiting_floats, line_children)
+             waiting_floats, line_children, first_letter_style, first_line_style)
         linebox.width, linebox.height = line.width, line.height
 
         if is_phantom_linebox(line) and not preserved_line_break:
@@ -126,7 +137,7 @@ def get_next_linebox(context, linebox, position_y, bottom_space, skip_stack,
         line.translate(offset_x, offset_y)
         # Avoid floating point errors, as position_y - top + top != position_y
         # Removing this line breaks the position == linebox.position test below
-        # See https://github.com/Kozea/WeasyPrint/issues/583
+        # See issue #583.
         line.position_y = position_y
 
         if line.height <= candidate_height:
@@ -137,6 +148,16 @@ def get_next_linebox(context, linebox, position_y, bottom_space, skip_stack,
         context.excluded_shapes = excluded_shapes
         position_x, position_y, available_width = avoid_collisions(
             context, line, containing_block, outer=False)
+
+        if first_line_style:
+            first_line_box = line.copy_with_children(line.children)
+            first_line_box.element_tag += '::first-line'
+            first_line_box.style = first_line_box.style.copy()
+            for key, value in first_line_style.items():
+                first_line_box.style[key] = value
+            line.children = [first_line_box]
+            _adjust_line_height(first_line_box)
+
         if containing_block.style['direction'] == 'ltr':
             condition = (position_x, position_y) == (
                 original_position_x, original_position_y)
@@ -169,8 +190,9 @@ def get_next_linebox(context, linebox, position_y, bottom_space, skip_stack,
             fixed_boxes, bottom_space, skip_stack=None)
         float_children.append(new_waiting_float)
         if waiting_float_resume_at:
-            context.broken_out_of_flow[new_waiting_float] = (
-                waiting_float, containing_block, waiting_float_resume_at)
+            context.add_broken_out_of_flow(
+                new_waiting_float, waiting_float, containing_block,
+                waiting_float_resume_at)
     if float_children:
         line.children += tuple(float_children)
 
@@ -280,8 +302,9 @@ def first_letter_to_box(box, skip_stack, first_letter_style):
         first_letter = ''
         child = box.children[0]
         if isinstance(child, boxes.TextBox):
-            letter_style = computed_from_cascaded(
-                cascaded={}, parent_style=first_letter_style, element=None)
+            letter_style = box.style.copy()
+            for key, value in first_letter_style.items():
+                letter_style[key] = value
             if child.element_tag.endswith('::first-letter'):
                 letter_box = boxes.InlineBox(
                     f'{box.element_tag}::first-letter', letter_style,
@@ -308,10 +331,10 @@ def first_letter_to_box(box, skip_stack, first_letter_style):
                     # "This type of initial letter is similar to an
                     # inline-level element if its 'float' property is 'none',
                     # otherwise it is similar to a floated element."
-                    if first_letter_style['float'] == 'none':
+                    if letter_style['float'] == 'none':
                         letter_box = boxes.InlineBox(
                             f'{box.element_tag}::first-letter',
-                            first_letter_style, box.element, [])
+                            letter_style, box.element, [])
                         text_box = boxes.TextBox(
                             f'{box.element_tag}::first-letter', letter_style,
                             box.element, first_letter)
@@ -320,8 +343,7 @@ def first_letter_to_box(box, skip_stack, first_letter_style):
                     else:
                         letter_box = boxes.BlockBox(
                             f'{box.element_tag}::first-letter',
-                            first_letter_style, box.element, [])
-                        letter_box.first_letter_style = None
+                            letter_style, box.element, [])
                         line_box = boxes.LineBox(
                             f'{box.element_tag}::first-letter', letter_style,
                             box.element, [])
@@ -334,10 +356,8 @@ def first_letter_to_box(box, skip_stack, first_letter_style):
                     build.process_text_transform(text_box)
                     if skip_stack and child_skip_stack:
                         index, = skip_stack
-                        (child_index, grandchild_skip_stack), = (
-                            child_skip_stack.items())
-                        skip_stack = {
-                            index: {child_index + 1: grandchild_skip_stack}}
+                        (child_index, grandchild_skip_stack), = child_skip_stack.items()
+                        skip_stack = {index: {child_index + 1: grandchild_skip_stack}}
         elif isinstance(child, boxes.ParentBox):
             if skip_stack:
                 child_skip_stack, = skip_stack.values()
@@ -395,10 +415,9 @@ def inline_block_box_layout(context, box, position_x, skip_stack,
     box.position_x = position_x
     box.position_y = 0
     box, _, _, _, _, _ = block_container_layout(
-        context, box, bottom_space=-inf, skip_stack=skip_stack,
-        page_is_empty=True, absolute_boxes=absolute_boxes,
-        fixed_boxes=fixed_boxes, adjoining_margins=None, discard=False,
-        max_lines=None)
+        context, box, bottom_space=-inf, skip_stack=skip_stack, page_is_empty=True,
+        absolute_boxes=absolute_boxes, fixed_boxes=fixed_boxes, adjoining_margins=None,
+        first_letter_style=None, first_line_style=None, discard=False, max_lines=None)
     box.baseline = inline_block_baseline(box)
     return box
 
@@ -438,19 +457,24 @@ def inline_block_width(box, context, containing_block):
 def split_inline_level(context, box, position_x, max_x, bottom_space,
                        skip_stack, containing_block, absolute_boxes,
                        fixed_boxes, line_placeholders, waiting_floats,
-                       line_children):
+                       line_children, first_letter_style, first_line_style):
     """Fit as much content as possible from an inline-level box in a width.
 
-    Return ``(new_box, resume_at, preserved_line_break, first_letter,
-    last_letter)``. ``resume_at`` is ``None`` if all of the content
-    fits. Otherwise it can be passed as a ``skip_stack`` parameter to resume
-    where we left off.
+    Return ``(new_box, resume_at, preserved_line_break, first_letter, last_letter)``.
+    ``resume_at`` is ``None`` if all of the content fits. Otherwise it can be passed as
+    a ``skip_stack`` parameter to resume where we left off.
 
     ``new_box`` is non-empty (unless the box is empty) and as big as possible
-    while being narrower than ``available_width``, if possible (may overflow
-    is no split is possible.)
+    while respecting ``max_x``, if possible (may overflow is no split is possible.)
 
     """
+    if first_line_style:
+        box = box.copy()
+        box.style = box.style.copy()
+        for key, value in first_line_style.items():
+            if key in INHERITED:
+                box.style[key] = value
+        build.process_text_transform(box)
     resolve_percentages(box, containing_block)
     float_widths = {'left': 0, 'right': 0}
     if isinstance(box, boxes.TextBox):
@@ -488,7 +512,7 @@ def split_inline_level(context, box, position_x, max_x, bottom_space,
          last_letter, float_widths) = split_inline_box(
              context, box, position_x, max_x, bottom_space, skip_stack,
              containing_block, absolute_boxes, fixed_boxes, line_placeholders,
-             waiting_floats, line_children)
+             waiting_floats, line_children, first_letter_style, first_line_style)
     elif isinstance(box, boxes.AtomicInlineLevelBox):
         new_box = atomic_box(
             context, box, position_x, skip_stack, containing_block,
@@ -568,8 +592,8 @@ def _out_of_flow_layout(context, box, containing_block, index, child,
                 context, child, containing_block, absolute_boxes, fixed_boxes,
                 bottom_space, skip_stack=None)
             if float_resume_at:
-                context.broken_out_of_flow[child] = (
-                    child, containing_block, float_resume_at)
+                context.add_broken_out_of_flow(
+                    child, child, containing_block, float_resume_at)
             waiting_children.append((index, new_child, child))
             child = new_child
 
@@ -602,10 +626,10 @@ def _out_of_flow_layout(context, box, containing_block, index, child,
         context.running_elements[running_name][page].append(child)
 
 
-def _break_waiting_children(context, box, max_x, bottom_space,
-                            initial_skip_stack, absolute_boxes, fixed_boxes,
-                            line_placeholders, waiting_floats, line_children,
-                            children, waiting_children):
+def _break_waiting_children(context, box, max_x, bottom_space, initial_skip_stack,
+                            absolute_boxes, fixed_boxes, line_placeholders,
+                            waiting_floats, line_children, children, waiting_children,
+                            first_letter_style, first_line_style):
     if waiting_children:
         # Too wide, try to cut inside waiting children, starting from the end.
         # TODO: we should take care of children added into absolute_boxes,
@@ -631,7 +655,7 @@ def _break_waiting_children(context, box, max_x, bottom_space,
                     context, original_child, child.position_x, max_x,
                     bottom_space, child_skip_stack, box, absolute_boxes,
                     fixed_boxes, line_placeholders, waiting_floats,
-                    line_children)
+                    line_children, first_letter_style, first_line_style)
                 if child_resume_at:
                     break
                 max_x -= 1
@@ -654,10 +678,38 @@ def _break_waiting_children(context, box, max_x, bottom_space,
         return {children[-1][0] + 1: None}
 
 
+def _adjust_line_height(box):
+    """Set margins to the half leading to respect line height.
+
+    Also compensate for borders and padding, we want margin_height() == line_height.
+
+    """
+    line_height, box.baseline = strut(box.style)
+    box.height = box.style['font_size']
+    half_leading = (line_height - box.height) / 2
+    box.margin_top = half_leading - box.border_top_width - box.padding_top
+    box.margin_bottom = half_leading - box.border_bottom_width - box.padding_bottom
+
+
 def split_inline_box(context, box, position_x, max_x, bottom_space, skip_stack,
-                     containing_block, absolute_boxes, fixed_boxes,
-                     line_placeholders, waiting_floats, line_children):
-    """Same behavior as split_inline_level."""
+                     containing_block, absolute_boxes, fixed_boxes, line_placeholders,
+                     waiting_floats, line_children, first_letter_style,
+                     first_line_style):
+    """Fit as much content as possible from an inline box in a width.
+
+    Return ``(new_box, resume_at, preserved_line_break, first_letter, last_letter)``.
+    ``resume_at`` is ``None`` if all of the content fits. Otherwise it can be passed as
+    a ``skip_stack`` parameter to resume where we left off.
+
+    ``new_box`` is non-empty (unless the box is empty) and as big as possible while
+    respecting ``max_x``, if possible (may overflow is no split is possible.)
+
+    This is the recursive step that loops over the children of the box; base steps of
+    recursion are handled by ``split_inline_level()``.
+
+    In this phase, excluded floating shapes are ignored.
+
+    """
 
     # In some cases (shrink-to-fit result being the preferred width)
     # max_x is coming from Pango itself,
@@ -715,7 +767,8 @@ def split_inline_box(context, box, position_x, max_x, bottom_space, skip_stack,
             split_inline_level(
                 context, child, position_x, available_width, bottom_space,
                 skip_stack, containing_block, absolute_boxes, fixed_boxes,
-                line_placeholders, child_waiting_floats, line_children))
+                line_placeholders, child_waiting_floats, line_children,
+                first_letter_style, first_line_style))
         if box.style['direction'] == 'rtl':
             end_spacing = left_spacing
             max_x -= new_float_widths['left']
@@ -730,7 +783,11 @@ def split_inline_box(context, box, position_x, max_x, bottom_space, skip_stack,
                 split_inline_level(
                     context, child, position_x, available_width, bottom_space,
                     skip_stack, containing_block, absolute_boxes, fixed_boxes,
-                    line_placeholders, child_waiting_floats, line_children))
+                    line_placeholders, child_waiting_floats, line_children,
+                    first_letter_style, first_line_style))
+
+        float_widths['left'] = max(float_widths['left'], new_float_widths['left'])
+        float_widths['right'] = max(float_widths['right'], new_float_widths['right'])
 
         skip_stack = None
         if preserved:
@@ -767,19 +824,19 @@ def split_inline_box(context, box, position_x, max_x, bottom_space, skip_stack,
             # May be None where we have an empty TextBox.
             assert isinstance(child, boxes.TextBox)
         else:
+            # Store lines to get previous break points.
             if isinstance(box, boxes.LineBox):
                 line_children.append((index, new_child))
-            trailing_whitespace = (
-                isinstance(new_child, boxes.TextBox) and
-                new_child.text and
-                unicodedata.category(new_child.text[-1]) == 'Zs')
-            new_position_x = new_child.position_x + new_child.margin_width()
 
-            if new_position_x > max_x and not trailing_whitespace:
+            # Check that text doesn’t overflow.
+            new_position_x = new_child.position_x + new_child.margin_width()
+            if new_position_x - trailing_whitespace_size(context, new_child) > max_x:
+                # Text overflows, find previous break point.
                 previous_resume_at = _break_waiting_children(
                     context, containing_block, max_x, bottom_space, initial_skip_stack,
-                    absolute_boxes, fixed_boxes, line_placeholders,
-                    waiting_floats, line_children, children, waiting_children)
+                    absolute_boxes, fixed_boxes, line_placeholders, waiting_floats,
+                    line_children, children, waiting_children, first_letter_style,
+                    first_line_style)
                 if previous_resume_at:
                     resume_at = previous_resume_at
                     break
@@ -836,15 +893,7 @@ def split_inline_box(context, box, position_x, max_x, bottom_space, skip_stack,
         new_box.width = position_x - content_box_left
         new_box.translate(dx=float_widths['left'], ignore_floats=True)
 
-    line_height, new_box.baseline = strut_layout(box.style, context)
-    new_box.height = box.style['font_size']
-    half_leading = (line_height - new_box.height) / 2
-    # Set margins to the half leading but also compensate for borders and
-    # paddings. We want margin_height() == line_height
-    new_box.margin_top = (
-        half_leading - new_box.border_top_width - new_box.padding_top)
-    new_box.margin_bottom = (
-        half_leading - new_box.border_bottom_width - new_box.padding_bottom)
+    _adjust_line_height(new_box)
 
     if new_box.style['position'] == 'relative':
         for absolute_box in absolute_boxes:
@@ -900,7 +949,7 @@ def split_text_box(context, box, available_width, skip, is_line_start=True):
         # "only the 'line-height' is used when calculating the height
         #  of the line box."
         # Set margins so that margin_height() == line_height
-        line_height, _ = strut_layout(box.style, context)
+        line_height, _ = strut(box.style)
         half_leading = (line_height - height) / 2
         box.margin_top = half_leading
         box.margin_bottom = half_leading
@@ -1019,7 +1068,7 @@ def inline_box_verticality(box, top_bottom_subtrees, baseline_y):
         if vertical_align == 'baseline':
             child_baseline_y = baseline_y
         elif vertical_align == 'middle':
-            one_ex = box.style['font_size'] * character_ratio(box.style, 'x')
+            one_ex = box.style['font_size'] * character_ratio(box.style, 'ex')
             top = baseline_y - (one_ex + child.margin_height()) / 2
             child_baseline_y = top + child.baseline
         elif vertical_align == 'text-top':
@@ -1037,6 +1086,10 @@ def inline_box_verticality(box, top_bottom_subtrees, baseline_y):
             # Later, we will assume for this subtree that its baseline
             # is at y=0.
             child_baseline_y = 0
+        elif isinstance(vertical_align, Pending):
+            height, _ = strut(box.style)
+            child_baseline_y = baseline_y - percentage(
+                vertical_align, box.style, height)
         else:
             # Numeric value: The child’s baseline is `vertical_align` above
             # (lower y) the parent’s baseline.

weasyprint/layout/page.py

@@ -1,10 +1,10 @@
 """Layout for pages and CSS3 margin boxes."""
 
 import copy
-from collections import namedtuple
+from collections import defaultdict, namedtuple
 from math import inf
 
-from ..css import computed_from_cascaded
+from ..css import AnonymousStyle
 from ..formatting_structure import boxes, build
 from ..logger import PROGRESS_LOGGER
 from .absolute import absolute_box_layout, absolute_layout
@@ -377,8 +377,7 @@ def make_margin_boxes(context, page, state):
         style = context.style_for(page.page_type, at_keyword)
         if style is None:
             # doesn't affect counters
-            style = computed_from_cascaded(
-                element=None, cascaded={}, parent_style=page.style)
+            style = AnonymousStyle(page.style)
         _standardize_page_based_counters(style, at_keyword)
         box = boxes.MarginBox(at_keyword, style)
         # Empty boxes should not be generated, but they may be needed for
@@ -493,7 +492,8 @@ def margin_box_content_layout(context, page, box):
     box, resume_at, next_page, _, _, _ = block_container_layout(
         context, box, bottom_space=-inf, skip_stack=None, page_is_empty=True,
         absolute_boxes=positioned_boxes, fixed_boxes=positioned_boxes,
-        adjoining_margins=None, discard=False, max_lines=None)
+        adjoining_margins=None, first_letter_style=None, first_line_style=None,
+        discard=False, max_lines=None)
     assert resume_at is None
     for absolute_box in positioned_boxes:
         absolute_layout(
@@ -622,38 +622,71 @@ def make_page(context, root_box, page_type, resume_at, page_number,
             context.reported_footnotes = reported_footnotes[i:]
             break
 
+    # Display out-of-flow boxes broken on the previous page.
+    # TODO: we shouldn’t separate broken in-flow and out-of-flow layout.
     page_is_empty = True
     adjoining_margins = []
     positioned_boxes = []  # Mixed absolute and fixed
     out_of_flow_boxes = []
+    excluded_shapes = defaultdict(list)
     broken_out_of_flow = {}
     context_out_of_flow = context.broken_out_of_flow.values()
     context.broken_out_of_flow = broken_out_of_flow
-    for box, containing_block, skip_stack in context_out_of_flow:
+    for box, containing_block, context_box, skip_stack in context_out_of_flow:
+        if context_box:
+            context.create_block_formatting_context(context_box)
         box.position_y = root_box.content_box_y()
         if box.is_floated():
             out_of_flow_box, out_of_flow_resume_at = float_layout(
                 context, box, containing_block, positioned_boxes,
                 positioned_boxes, 0, skip_stack)
+            excluded_shapes[context_box].append(out_of_flow_box)
         else:
             assert box.is_absolutely_positioned()
             out_of_flow_box, out_of_flow_resume_at = absolute_box_layout(
                 context, box, containing_block, positioned_boxes, 0,
                 skip_stack)
         out_of_flow_boxes.append(out_of_flow_box)
+        page_is_empty = False
         if out_of_flow_resume_at:
-            broken_out_of_flow[out_of_flow_box] = (
-                box, containing_block, out_of_flow_resume_at)
+            context.add_broken_out_of_flow(
+                out_of_flow_box, box, containing_block, out_of_flow_resume_at)
+        if context_box:
+            context.finish_block_formatting_context()
+
+    # Set excluded shapes from broken out-of-flow for in-flow content.
+    for context_box, shapes in excluded_shapes.items():
+        context._excluded_shapes[context_box] = shapes
+
+    # Display in-flow content.
+    initial_root_box = root_box
+    initial_resume_at = resume_at
     root_box, resume_at, next_page, _, _, _ = block_level_layout(
         context, root_box, 0, resume_at, initial_containing_block,
         page_is_empty, positioned_boxes, positioned_boxes, adjoining_margins)
-    assert root_box
+    if not root_box:
+        # In-flow page rendering didn’t progress, only out-of-flow did. Render empty box
+        # at skip_stack and force fragmentation to make the root box and its descendants
+        # cover the whole page height.
+        assert not page_is_empty
+        box = parent = initial_root_box = initial_root_box.deepcopy()
+        skip_stack = initial_resume_at
+        while skip_stack and len(skip_stack) == 1:
+            (skip, skip_stack), = skip_stack.items()
+            box, parent = box.children[skip], box
+        parent.children = []
+        parent.force_fragmentation = True
+        root_box, _, _, _, _, _ = block_level_layout(
+            context, initial_root_box, 0, initial_resume_at, initial_containing_block,
+            True, positioned_boxes, positioned_boxes, adjoining_margins)
+        resume_at = initial_resume_at
     root_box.children = out_of_flow_boxes + root_box.children
 
     footnote_area = build.create_anonymous_boxes(footnote_area.deepcopy())
     footnote_area = block_level_layout(
-        context, footnote_area, -inf, None, footnote_area.page, True,
-        positioned_boxes, positioned_boxes)[0]
+        context, footnote_area, bottom_space=-inf, skip_stack=None,
+        containing_block=footnote_area.page, page_is_empty=True,
+        absolute_boxes=positioned_boxes, fixed_boxes=positioned_boxes)[0]
     footnote_area.translate(dy=-footnote_area.margin_height())
 
     page.fixed_boxes = [
@@ -664,7 +697,7 @@ def make_page(context, root_box, page_type, resume_at, page_number,
             context, absolute_box, page, positioned_boxes, bottom_space=0,
             skip_stack=None)
 
-    context.finish_block_formatting_context(root_box)
+    context.finish_block_formatting_context()
 
     page.children = [root_box, footnote_area]
 

weasyprint/layout/percent.py

@@ -2,19 +2,22 @@
 
 from math import inf
 
+from ..css import resolve_math
+from ..css.functions import check_math
 from ..formatting_structure import boxes
 
 
-def percentage(value, refer_to):
+def percentage(value, computed, refer_to):
     """Return the percentage of the reference value, or the value unchanged.
 
-    ``refer_to`` is the length for 100%. If ``refer_to`` is not a number, it
-    just replaces percentages.
+    ``refer_to`` is the length for 100%.
 
     """
+    if check_math(value):
+        value = resolve_math(value, computed, refer_to=refer_to)
     if value is None or value == 'auto':
         return value
-    elif value.unit == 'px':
+    elif value.unit.lower() == 'px':
         return value.value
     else:
         assert value.unit == '%'
@@ -31,7 +34,7 @@ def resolve_one_percentage(box, property_name, refer_to):
     # box.style has computed values
     value = box.style[property_name]
     # box attributes are used values
-    percent = percentage(value, refer_to)
+    percent = percentage(value, box.style, refer_to)
     setattr(box, property_name, percent)
     if property_name in ('min_width', 'min_height') and percent == 'auto':
         setattr(box, property_name, 0)
@@ -75,10 +78,10 @@ def resolve_percentages(box, containing_block):
         # Special handling when the height of the containing block
         # depends on its content.
         height = box.style['height']
-        if height == 'auto' or height.unit == '%':
+        if height == 'auto' or check_math(height) or height.unit == '%':
             box.height = 'auto'
         else:
-            assert height.unit == 'px'
+            assert height.unit.lower() == 'px'
             box.height = height.value
         resolve_one_percentage(box, 'min_height', 0)
         resolve_one_percentage(box, 'max_height', inf)
@@ -104,7 +107,8 @@ def resolve_percentages(box, containing_block):
 def resolve_radii_percentages(box):
     for corner in ('top_left', 'top_right', 'bottom_right', 'bottom_left'):
         property_name = f'border_{corner}_radius'
-        rx, ry = box.style[property_name]
+        computed = box.style[property_name]
+        rx, ry = computed
 
         # Short track for common case
         if (0, 'px') in (rx, ry):
@@ -116,8 +120,8 @@ def resolve_radii_percentages(box):
                 setattr(box, property_name, (0, 0))
                 break
         else:
-            rx = percentage(rx, box.border_width())
-            ry = percentage(ry, box.border_height())
+            rx = percentage(rx, box.style, box.border_width())
+            ry = percentage(ry, box.style, box.border_height())
             setattr(box, property_name, (rx, ry))