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

weasyprint/layout/block.py

@@ -298,9 +298,13 @@ def _out_of_flow_layout(context, box, index, child, new_children,
     return stop, resume_at, new_child, out_of_flow_resume_at
 
 
-def _break_line(context, box, line, new_children, lines_iterator,
-                page_is_empty, index, skip_stack, resume_at, absolute_boxes,
-                fixed_boxes):
+def _break_line(context, box, line, new_children, next_lines, page_is_empty, index,
+                skip_stack, resume_at, absolute_boxes, fixed_boxes):
+    """Break line where allowed by orphans and widows.
+
+    Return (abort, stop, resume_at).
+
+    """
     over_orphans = len(new_children) - box.style['orphans']
     if over_orphans < 0 and not page_is_empty:
         # Reached the bottom of the page before we had
@@ -309,12 +313,7 @@ def _break_line(context, box, line, new_children, lines_iterator,
         return True, False, resume_at
     # How many lines we need on the next page to satisfy widows
     # -1 for the current line.
-    needed = box.style['widows'] - 1
-    if needed:
-        for _ in lines_iterator:
-            needed -= 1
-            if needed == 0:
-                break
+    needed = max(box.style['widows'] - 1 - next_lines, 0)
     if needed > over_orphans and not page_is_empty:
         # Total number of lines < orphans + widows
         remove_placeholders(context, line.children, absolute_boxes, fixed_boxes)
@@ -366,24 +365,52 @@ def _linebox_layout(context, box, index, child, new_children, page_is_empty,
         else:
             offset_y = 0
 
-        # Allow overflow if the first line of the page is higher
-        # than the page itself so that we put *something* on this
-        # page and can advance in the context.
+        # Allow overflow if the first line of the page is higher than the page itself so
+        # that we put *something* on this page and can advance in the context.
         overflow = (
             (new_children or not page_is_empty) and
             context.overflows_page(bottom_space, new_position_y + offset_y))
         if overflow:
-            abort, stop, resume_at = _break_line(
-                context, box, line, new_children, lines_iterator,
-                page_is_empty, index, skip_stack, resume_at, absolute_boxes,
-                fixed_boxes)
+            # If we couldn’t break the line before but can break now, first try to
+            # report footnotes and see if we don’t overflow.
+            could_break_before = can_break_now = True
+            next_lines = len(tuple(lines_iterator))
+            if len(new_children) + 1 < box.style['orphans']:
+                can_break_now = False
+            elif next_lines < box.style['widows']:
+                can_break_now = False
+            if len(new_children) < box.style['orphans']:
+                could_break_before = False
+            elif next_lines + 1 < box.style['widows']:
+                could_break_before = False
+            report = not context.in_column and can_break_now and not could_break_before
+            reported_footnotes = 0
+            while report and context.current_page_footnotes:
+                context.report_footnote(context.current_page_footnotes[-1])
+                reported_footnotes += 1
+                if not context.overflows_page(bottom_space, new_position_y + offset_y):
+                    new_children.append(line)
+                    stop = True
+                    break
+            else:
+                abort, stop, resume_at = _break_line(
+                    context, box, line, new_children, next_lines,
+                    page_is_empty, index, skip_stack, resume_at, absolute_boxes,
+                    fixed_boxes)
+
+            # Revert reported footnotes, as they’ve been reported starting from the last
+            # one.
+            if reported_footnotes >= 2:
+                extra = context.reported_footnotes[-1:-reported_footnotes-1:-1]
+                context.reported_footnotes[-reported_footnotes:] = extra
+
             break
 
         # TODO: this is incomplete.
         # See https://drafts.csswg.org/css-page-3/#allowed-pg-brk
         # "When an unforced page break occurs here, both the adjoining
         #  ‘margin-top’ and ‘margin-bottom’ are set to zero."
-        # See https://github.com/Kozea/WeasyPrint/issues/115
+        # See issue #115.
         elif page_is_empty and context.overflows_page(
                 bottom_space, new_position_y):
             # Remove the top border when a page is empty and the box is
@@ -413,9 +440,10 @@ def _linebox_layout(context, box, index, child, new_children, page_is_empty,
                     # even try.
                     if new_children or not page_is_empty:
                         if footnote.style['footnote_policy'] == 'line':
+                            next_lines = len(tuple(lines_iterator))
                             abort, stop, resume_at = _break_line(
                                 context, box, line, new_children,
-                                lines_iterator, page_is_empty, index,
+                                next_lines, page_is_empty, index,
                                 skip_stack, resume_at, absolute_boxes,
                                 fixed_boxes)
                             break_linebox = True
@@ -502,7 +530,6 @@ def _in_flow_layout(context, box, index, child, new_children, page_is_empty,
         if box.is_table_wrapper:  # should not be a special case
             collapsed_margin = collapse_margin(adjoining_margins)
             child.position_y += collapsed_margin
-            position_y += collapsed_margin
             adjoining_margins = []
         elif not isinstance(child, boxes.BlockBox):  # blocks handle that themselves
             if child.style['margin_top'] == 'auto':
@@ -512,7 +539,6 @@ def _in_flow_layout(context, box, index, child, new_children, page_is_empty,
             adjoining_margins.append(margin_top)
             offset_y = collapse_margin(adjoining_margins) - margin_top
             child.position_y += offset_y
-            position_y += offset_y
             adjoining_margins = []
 
     page_is_empty_with_no_children = page_is_empty and not any(
@@ -677,8 +703,7 @@ def block_container_layout(context, box, bottom_space, skip_stack,
 
     new_children = []
     next_page = {'break': 'any', 'page': None}
-    all_footnotes = []
-    broken_out_of_flow = {}
+    broken_out_of_flow = []
 
     last_in_flow_child = None
 
@@ -704,8 +729,13 @@ def block_container_layout(context, box, bottom_space, skip_stack,
                     absolute_boxes, fixed_boxes, adjoining_margins,
                     bottom_space))
             if out_of_flow_resume_at:
-                broken_out_of_flow[new_child] = (
+                context.broken_out_of_flow[new_child] = (
                     child, box, out_of_flow_resume_at)
+                broken_out_of_flow.append(new_child)
+            if child.is_outside_marker:
+                new_child.position_x = box.border_box_x()
+                if child.style['direction'] == 'rtl':
+                    new_child.position_x += box.width + box.padding_right
 
         elif isinstance(child, boxes.LineBox):
             (abort, stop, resume_at, position_y,
@@ -716,7 +746,6 @@ def block_container_layout(context, box, bottom_space, skip_stack,
                 draw_bottom_decoration, max_lines)
             draw_bottom_decoration |= resume_at is None
             adjoining_margins = []
-            all_footnotes += new_footnotes
 
         else:
             (abort, stop, resume_at, position_y, adjoining_margins,
@@ -766,7 +795,7 @@ def block_container_layout(context, box, bottom_space, skip_stack,
     else:
         resume_at = None
 
-    box_is_fragmented = resume_at is not None
+    box_is_fragmented = resume_at is not None or box.force_fragmentation
     if box.style['continue'] == 'discard':
         resume_at = None
 
@@ -775,11 +804,10 @@ def block_container_layout(context, box, bottom_space, skip_stack,
             not page_is_empty):
         remove_placeholders(
             context, [*new_children, *box.children[skip:]], absolute_boxes, fixed_boxes)
+        for child in broken_out_of_flow:
+            del context.broken_out_of_flow[child]
         return None, None, {'break': 'any', 'page': None}, [], False, max_lines
 
-    for key, value in broken_out_of_flow.items():
-        context.broken_out_of_flow[key] = value
-
     if collapsing_with_children:
         box.position_y += (
             collapse_margin(this_box_adjoining_margins) - box.margin_top)
@@ -831,7 +859,10 @@ def block_container_layout(context, box, bottom_space, skip_stack,
                 float_box.position_y + float_box.margin_height()
                 for float_box in context.excluded_shapes)
             position_y = max(max_float_position_y, position_y)
-        new_box.height = position_y - new_box.content_box_y()
+        if position_y == new_box.content_box_y() == inf:
+            new_box.height = 0
+        else:
+            new_box.height = position_y - new_box.content_box_y()
 
     if new_box.style['position'] == 'relative':
         # New containing block, resolve the layout of the absolute descendants

weasyprint/layout/column.py

@@ -190,6 +190,7 @@ def columns_layout(context, box, bottom_space, skip_stack, containing_block,
                         in_flow_children[-1].margin_height() +
                         in_flow_children[-1].position_y - current_position_y)
                     empty_space = height - consumed_height
+                    consumed_height -= in_flow_children[-1].margin_bottom
 
                     # Get the minimum size needed to render the next box
                     if column_skip_stack:

weasyprint/layout/flex.py

@@ -172,6 +172,8 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
                     child.style['image_resolution'], child.style['font_size'])
                 if intrinsic_ratio and intrinsic_height:
                     transferred_size = intrinsic_height * intrinsic_ratio
+                    content_size = max(
+                        child.min_width, min(child.max_width, content_size))
             if specified_size != 'auto':
                 child.min_width = min(specified_size, content_size)
             elif transferred_size is not None:
@@ -183,12 +185,12 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
             specified_size = child.height
             new_child = child.copy()
             new_child.style = child.style.copy()
-            if new_child.style['width'] == 'auto':
-                new_child_width = max_content_width(context, new_child)
-                new_child.style['width'] = Dimension(new_child_width, 'px')
             new_child.style['height'] = 'auto'
             new_child.style['min_height'] = Dimension(0, 'px')
             new_child.style['max_height'] = Dimension(inf, 'px')
+            if new_child.style['width'] == 'auto':
+                new_child_width = max_content_width(context, new_child)
+                new_child.style['width'] = Dimension(new_child_width, 'px')
             new_child = block.block_level_layout(
                 context, new_child, bottom_space, child_skip_stack, parent_box,
                 page_is_empty)[0]
@@ -200,6 +202,12 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
                     child.style['image_resolution'], child.style['font_size'])
                 if intrinsic_ratio and intrinsic_width:
                     transferred_size = intrinsic_width / intrinsic_ratio
+                    content_size = max(
+                        child.min_height, min(child.max_height, content_size))
+                elif not intrinsic_width:
+                    # TODO: wrongly set by block_level_layout, would be OK with
+                    # min_content_height.
+                    content_size = 0
             if specified_size != 'auto':
                 child.min_height = min(specified_size, content_size)
             elif transferred_size is not None:
@@ -242,17 +250,31 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
             pass
         else:
             # 3.E Otherwise…
+            new_child = child.copy()
+            new_child.style = child.style.copy()
             if main == 'width':
-                child.flex_base_size = max_content_width(context, child, outer=False)
+                # … the item’s min and max main sizes are ignored.
+                new_child.style['min_width'] = Dimension(0, 'px')
+                new_child.style['max_width'] = Dimension(inf, 'px')
+
+                child.flex_base_size = max_content_width(
+                    context, new_child, outer=False)
                 child.main_outer_extra = (
                     max_content_width(context, child) - child.flex_base_size)
             else:
-                new_child = child.copy()
+                # … the item’s min and max main sizes are ignored.
+                new_child.style['min_height'] = Dimension(0, 'px')
+                new_child.style['max_height'] = Dimension(inf, 'px')
+
                 new_child.width = inf
-                new_child = block.block_level_layout(
+                new_child, _, _, adjoining_margins, _, _ = block.block_level_layout(
                     context, new_child, bottom_space, child_skip_stack, parent_box,
-                    page_is_empty, absolute_boxes, fixed_boxes)[0]
+                    page_is_empty, absolute_boxes, fixed_boxes)
                 if new_child:
+                    # As flex items margins never collapse (with other flex items or
+                    # with the flex container), we can add the adjoining margins to the
+                    # child height.
+                    new_child.height += block.collapse_margin(adjoining_margins)
                     child.flex_base_size = new_child.height
                     child.main_outer_extra = (
                         new_child.margin_height() - new_child.height)
@@ -477,8 +499,8 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
                 child.height = new_child.height
                 # As flex items margins never collapse (with other flex items or
                 # with the flex container), we can add the adjoining margins to the
-                # child bottom margin.
-                child.margin_bottom += block.collapse_margin(adjoining_margins)
+                # child height.
+                child.height += block.collapse_margin(adjoining_margins)
             else:
                 if child.width == 'auto':
                     min_width = min_content_width(context, child, outer=False)
@@ -591,9 +613,9 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
                 align_self = align_items
             if 'stretch' in align_self and child.style[cross] == 'auto':
                 cross_margins = (
-                    (child.margin_top, child.margin_bottom)
-                    if cross == 'height'
-                    else (child.margin_left, child.margin_right))
+                    (child.style['margin_top'], child.style['margin_bottom'])
+                    if cross == 'height' else
+                    (child.style['margin_left'], child.style['margin_right']))
                 if 'auto' not in cross_margins:
                     cross_size = line.cross_size
                     if cross == 'height':
@@ -733,8 +755,9 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
             line.lower_baseline = line[0][1]._baseline if line else 0
         for index, child in line:
             cross_margins = (
-                (child.margin_top, child.margin_bottom) if cross == 'height'
-                else (child.margin_left, child.margin_right))
+                (child.style['margin_top'], child.style['margin_bottom'])
+                if cross == 'height' else
+                (child.style['margin_left'], child.style['margin_right']))
             auto_margins = sum([margin == 'auto' for margin in cross_margins])
             # If a flex item has auto cross-axis margins…
             if auto_margins:
@@ -755,14 +778,14 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
                     # If its outer cross size is less than the cross size…
                     extra_cross /= auto_margins
                     if cross == 'height':
-                        if child.margin_top == 'auto':
+                        if child.style['margin_top'] == 'auto':
                             child.margin_top = extra_cross
-                        if child.margin_bottom == 'auto':
+                        if child.style['margin_bottom'] == 'auto':
                             child.margin_bottom = extra_cross
                     else:
-                        if child.margin_left == 'auto':
+                        if child.style['margin_left'] == 'auto':
                             child.margin_left = extra_cross
-                        if child.margin_right == 'auto':
+                        if child.style['margin_right'] == 'auto':
                             child.margin_right = extra_cross
                 else:
                     # Otherwise…
@@ -815,9 +838,6 @@ def flex_layout(context, box, bottom_space, skip_stack, containing_block, page_i
                                 margins += (
                                     child.border_left_width + child.border_right_width +
                                     child.padding_left + child.padding_right)
-                        # TODO: Don't set style width, find a way to avoid width
-                        # re-calculation after 16.
-                        child.style[cross] = Dimension(line.cross_size - margins, 'px')
         position_cross += line.cross_size
 
     # 15 Determine the flex container’s used cross size.

weasyprint/layout/float.py

@@ -1,5 +1,7 @@
 """Layout for floating boxes."""
 
+from math import inf
+
 from ..formatting_structure import boxes
 from .min_max import handle_min_max_width
 from .percent import resolve_percentages, resolve_position_percentages
@@ -115,9 +117,14 @@ def find_float_position(context, box, containing_block):
 
 def get_clearance(context, box, collapsed_margin=0):
     """Return None if there is no clearance, otherwise the clearance value."""
+    # Box should be after shape that’s broken on this page.
+    for broken_shape in context.broken_out_of_flow:
+        if broken_shape.is_floated():
+            if box.style['clear'] in (broken_shape.style['float'], 'both'):
+                return inf
+    # Hypothetical position is the position of the top border edge
     clearance = None
     hypothetical_position = box.position_y + collapsed_margin
-    # Hypothetical position is the position of the top border edge
     for excluded_shape in context.excluded_shapes:
         if box.style['clear'] in (excluded_shape.style['float'], 'both'):
             y, h = excluded_shape.position_y, excluded_shape.margin_height()

weasyprint/layout/grid.py

@@ -1115,7 +1115,7 @@ def grid_layout(context, box, bottom_space, skip_stack, containing_block,
         sum(size for size, _ in rows_sizes[skip_row:]) +
         (len(rows_sizes[skip_row:]) - 1) * row_gap)
     row_lines_positions = (
-        rows_positions[skip_row + 1:] + [box.content_box_y() + total_height])
+        [*rows_positions[skip_row + 1:], box.content_box_y() + total_height])
     for i, row_y in enumerate(row_lines_positions, start=skip_row + 1):
         if context.overflows_page(bottom_space, row_y - skip_height):
             if not page_is_empty:

weasyprint/layout/inline.py

@@ -30,7 +30,7 @@ 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
@@ -126,7 +126,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:
@@ -767,15 +767,14 @@ 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,

weasyprint/layout/page.py

@@ -622,6 +622,8 @@ 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
@@ -641,13 +643,33 @@ def make_page(context, root_box, page_type, resume_at, page_number,
                 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)
+
+    # 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,
+            page_is_empty, 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())

weasyprint/layout/preferred.py

@@ -270,37 +270,43 @@ def table_cell_min_max_content_width(context, box, outer=True):
 
 def inline_line_widths(context, box, outer, is_line_start, minimum, skip_stack=None,
                        first_line=False):
+    """Yield line width for each line."""
+
+    # Set text indent.
+    text_indent = 0
     if isinstance(box, boxes.LineBox) and box.style['text_indent'].unit != '%':
         text_indent = box.style['text_indent'].value
-    else:
-        text_indent = 0
 
+    # Yield widths for each line.
     current_line = 0
     if skip_stack is None:
         skip = 0
     else:
         (skip, skip_stack), = skip_stack.items()
     for child in box.children[skip:]:
+        # Skip absolutely positioned elements.
         if child.is_absolutely_positioned():
-            continue  # Skip
+            continue
 
+        # None is used in "lines" to track line breaks, transformed to 0 when yielded.
         if isinstance(child, boxes.InlineBox):
+            # Inline box, call function recursively.
             lines = inline_line_widths(
-                context, child, outer, is_line_start, minimum, skip_stack,
-                first_line)
+                context, child, outer, is_line_start, minimum, skip_stack, first_line)
             if first_line:
-                lines = [next(lines)]
+                lines = [next(lines) or None]
             else:
-                lines = list(lines)
+                lines = [line or None for line in lines]
             if len(lines) == 1:
-                lines[0] = adjust(child, outer, lines[0])
+                lines[0] = adjust(child, outer, lines[0] or 0)
             else:
-                lines[0] = adjust(child, outer, lines[0], right=False)
-                lines[-1] = adjust(child, outer, lines[-1], left=False)
+                lines[0] = adjust(child, outer, lines[0] or 0, right=False) or None
+                lines[-1] = adjust(child, outer, lines[-1] or 0, left=False) or None
         elif isinstance(child, boxes.TextBox):
-            space_collapse = child.style['white_space'] in (
-                'normal', 'nowrap', 'pre-line')
-            text_wrap = child.style['white_space'] in ('normal', 'pre-wrap', 'pre-line')
+            # Text box, split into lines.
+            white_space = child.style['white_space']
+            space_collapse = white_space in ('normal', 'nowrap', 'pre-line')
+            text_wrap = white_space in ('normal', 'pre-wrap', 'pre-line')
             if skip_stack is None:
                 skip = 0
             else:
@@ -318,18 +324,21 @@ def inline_line_widths(context, box, outer, is_line_start, minimum, skip_stack=N
                     child_text[resume_index:].decode(), child.style, context, max_width,
                     child.justification_spacing, is_line_start=is_line_start,
                     minimum=True)
-                lines.append(width)
+                lines.append(width or None)
                 if first_line:
                     break
             if first_line and new_resume_index:
-                current_line += lines[0]
+                # We only need the first line, break early.
+                current_line += lines[0] or 0
                 break
             # TODO: use the real next character instead of 'a' to detect line breaks.
-            can_break = can_break_text(
-                child_text.decode()[-1:] + 'a', child.style['lang'])
+            last_letter = child_text.decode()[-1:]
+            can_break = can_break_text(last_letter + 'a', child.style['lang'])
             if minimum and text_wrap and can_break:
-                lines.append(0)
+                # Add all possible line breaks for minimal width.
+                lines.append(None)
         else:
+            # Replaced elements, inline blocks…
             # https://www.w3.org/TR/css-text-3/#overflow-wrap
             # "The line breaking behavior of a replaced element
             #  or other atomic inline is equivalent to that
@@ -338,20 +347,20 @@ def inline_line_widths(context, box, outer, is_line_start, minimum, skip_stack=N
             # "By default, there is a break opportunity
             #  both before and after any inline object."
             if minimum:
-                lines = [0, min_content_width(context, child), 0]
+                lines = [None, min_content_width(context, child), None]
             else:
                 lines = [max_content_width(context, child)]
-        # The first text line goes on the current line
-        current_line += lines[0]
+        # The first text line goes on the current line.
+        current_line += lines[0] or 0
         if len(lines) > 1:
-            # Forced line break
+            # Forced line break(s).
             yield current_line + text_indent
             text_indent = 0
             if len(lines) > 2:
                 for line in lines[1:-1]:
-                    yield line
-            current_line = lines[-1]
-        is_line_start = lines[-1] == 0
+                    yield line or 0
+            current_line = lines[-1] or 0
+        is_line_start = lines[-1] is None
         skip_stack = None
     yield current_line + text_indent
 
@@ -743,17 +752,30 @@ def trailing_whitespace_size(context, box):
     """Return the size of the trailing whitespace of ``box``."""
     from .inline import split_first_line, split_text_box
 
+    # Find last box child, keep last parent to remove nested trailing spaces.
+    last_parent = None
     while isinstance(box, (boxes.InlineBox, boxes.LineBox)):
         if not box.children:
             return 0
-        box = box.children[-1]
-    if not (isinstance(box, boxes.TextBox) and box.text and
-            box.style['white_space'] in ('normal', 'nowrap', 'pre-line')):
+        last_parent, box = box, box.children[-1]
+
+    # Return early if possible.
+    if not isinstance(box, boxes.TextBox) or not box.text:
+        # There’s no text in last child.
         return 0
-    stripped_text = box.text.rstrip(' ')
-    if box.style['font_size'] == 0 or len(stripped_text) == len(box.text):
+    elif box.style['white_space'] not in ('normal', 'nowrap', 'pre-line'):
+        # Spaces don’t collapse.
         return 0
-    if stripped_text:
+    elif box.style['font_size'] == 0:
+        # Trailing spaces take no space.
+        return 0
+    elif not box.text.endswith(' '):
+        # No trailing space.
+        return 0
+
+    # Strip text.
+    if stripped_text := box.text.rstrip(' '):
+        # Stripped text is not empty, calculate width difference.
         resume = 0
         while resume is not None:
             old_resume = resume
@@ -763,12 +785,17 @@ def trailing_whitespace_size(context, box):
         stripped_box, resume, _ = split_text_box(
             context, stripped_box, None, old_resume)
         if stripped_box is None:
-            # old_box split just before the trailing spaces
+            # Old box is split just before the trailing spaces.
             return old_box.width
         else:
+            # Return difference between old width and stripped width.
             assert resume is None
             return old_box.width - stripped_box.width
     else:
+        # Stripped text is empty, render spaces to get width.
         _, _, _, width, _, _ = split_first_line(
             box.text, box.style, context, None, box.justification_spacing)
+        # Remove possible trailing spaces from previous child.
+        if last_parent and len(last_parent.children) >= 2:
+            width += trailing_whitespace_size(context, last_parent.children[-2])
         return width

weasyprint/layout/table.py

@@ -414,9 +414,13 @@ def table_layout(context, table, bottom_space, skip_stack, containing_block,
                     if avoid_page_break(page_break, context):
                         earlier_page_break = find_earlier_page_break(
                             context, new_table_children, absolute_boxes, fixed_boxes)
-                        if earlier_page_break is not None:
-                            new_table_children, resume_at = earlier_page_break
-                            break
+                        if earlier_page_break is None:
+                            remove_placeholders(
+                                context, new_table_children, absolute_boxes,
+                                fixed_boxes)
+                            return None, None, next_page, position_y
+                        new_table_children, resume_at = earlier_page_break
+                        break
                     resume_at = {index_group: None}
                 else:
                     return None, None, next_page, position_y
@@ -782,7 +786,7 @@ def auto_table_layout(context, box, containing_block):
 
     if assignable_width < sum(max_content_guess):
         # Default values shouldn't be used, but we never know.
-        # See https://github.com/Kozea/WeasyPrint/issues/770
+        # See issue #770.
         lower_guess = guesses[0]
         upper_guess = guesses[-1]