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

weasyprint/draw/border.py

@@ -1,13 +1,12 @@
 """Draw borders."""
 
-from math import ceil, floor, pi, sqrt, tan
+from math import ceil, cos, floor, pi, sin, sqrt, tan
 
 from ..formatting_structure import boxes
 from ..layout import replaced
 from ..layout.percent import percentage
 from ..matrix import Matrix
 from .color import get_color, styled_color
-from .stack import stacked
 
 SIDES = ('top', 'right', 'bottom', 'left')
 
@@ -26,6 +25,34 @@ def set_mask_border(stream, box):
         box.style['mask_border_width'])
 
 
+def draw_column_rules(stream, box):
+    """Draw the column rules to a ``pdf.stream.Stream``."""
+    border_widths = (0, 0, 0, box.style['column_rule_width'])
+    skip_next = True
+    for child in box.children:
+        if child.style['column_span'] == 'all':
+            skip_next = True
+            continue
+        elif skip_next:
+            skip_next = False
+            continue
+        with stream.stacked():
+            rule_width = box.style['column_rule_width']
+            rule_style = box.style['column_rule_style']
+            if box.style['column_gap'] == 'normal':
+                gap = box.style['font_size']  # normal equals 1em
+            else:
+                gap = percentage(box.style['column_gap'], box.width)
+            position_x = (
+                child.position_x - (box.style['column_rule_width'] + gap) / 2)
+            border_box = position_x, child.position_y, rule_width, child.height
+            clip_border_segment(
+                stream, rule_style, rule_width, 'left', border_box, border_widths)
+            color = styled_color(
+                rule_style, get_color(box.style, 'column_rule_color'), 'left')
+            draw_rect_border(stream, border_box, border_widths, rule_style, color)
+
+
 def draw_border(stream, box):
     """Draw the box borders and column rules to a ``pdf.stream.Stream``."""
 
@@ -33,43 +60,22 @@ def draw_border(stream, box):
     if box.style['visibility'] != 'visible':
         return
 
-    # Draw column borders.
+    # Draw column rules.
     columns = (
         isinstance(box, boxes.BlockContainerBox) and (
             box.style['column_width'] != 'auto' or
             box.style['column_count'] != 'auto'))
     if columns and box.style['column_rule_width']:
-        border_widths = (0, 0, 0, box.style['column_rule_width'])
-        skip_next = True
-        for child in box.children:
-            if child.style['column_span'] == 'all':
-                skip_next = True
-                continue
-            elif skip_next:
-                skip_next = False
-                continue
-            with stacked(stream):
-                rule_width = box.style['column_rule_width']
-                rule_style = box.style['column_rule_style']
-                if box.style['column_gap'] == 'normal':
-                    gap = box.style['font_size']  # normal equals 1em
-                else:
-                    gap = percentage(box.style['column_gap'], box.width)
-                position_x = (
-                    child.position_x - (box.style['column_rule_width'] + gap) / 2)
-                border_box = (position_x, child.position_y, rule_width, child.height)
-                clip_border_segment(
-                    stream, rule_style, rule_width, 'left', border_box, border_widths)
-                color = styled_color(
-                    rule_style, get_color(box.style, 'column_rule_color'), 'left')
-                draw_rect_border(stream, border_box, border_widths, rule_style, color)
+        with stream.artifact():
+            draw_column_rules(stream, box)
 
     # If there's a border image, that takes precedence.
     if box.style['border_image_source'][0] != 'none' and box.border_image is not None:
-        draw_border_image(
-            box, stream, box.border_image, box.style['border_image_slice'],
-            box.style['border_image_repeat'], box.style['border_image_outset'],
-            box.style['border_image_width'])
+        with stream.artifact():
+            draw_border_image(
+                box, stream, box.border_image, box.style['border_image_slice'],
+                box.style['border_image_repeat'], box.style['border_image_outset'],
+                box.style['border_image_width'])
         return
 
     widths = [getattr(box, f'border_{side}_width') for side in SIDES]
@@ -88,7 +94,8 @@ def draw_border(stream, box):
     four_sides = 0 not in widths  # no 0-width border, to avoid PDF artifacts
     if simple_style and single_color and four_sides:
         # Simple case, we only draw rounded rectangles.
-        draw_rounded_border(stream, box, styles[0], colors[0])
+        with stream.artifact():
+            draw_rounded_border(stream, box, styles[0], colors[0])
         return
 
     # We're not smart enough to find a good way to draw the borders, we must
@@ -99,12 +106,11 @@ def draw_border(stream, box):
         side, width, color, style = values[index]
         if width == 0 or not color:
             continue
-        with stacked(stream):
+        with stream.artifact(), stream.stacked():
             clip_border_segment(
                 stream, style, width, side, box.rounded_border_box()[:4],
                 widths, box.rounded_border_box()[4:])
-            draw_rounded_border(
-                stream, box, style, styled_color(style, color, side))
+            draw_rounded_border(stream, box, style, styled_color(style, color, side))
 
 
 def draw_border_image(box, stream, image, border_slice, border_repeat, border_outset,
@@ -237,7 +243,7 @@ def draw_border_image(box, stream, image, border_slice, border_repeat, border_ou
         offset_x = rendered_width * slice_x / intrinsic_width
         offset_y = rendered_height * slice_y / intrinsic_height
 
-        with stacked(stream):
+        with stream.stacked():
             stream.rectangle(x, y, width, height)
             stream.clip()
             stream.end()
@@ -245,7 +251,7 @@ def draw_border_image(box, stream, image, border_slice, border_repeat, border_ou
             stream.transform(a=scale_x, d=scale_y)
             for i in range(n_repeats_x):
                 for j in range(n_repeats_y):
-                    with stacked(stream):
+                    with stream.stacked():
                         translate_x = i * (slice_width + extra_dx)
                         translate_y = j * (slice_height + extra_dy)
                         stream.transform(e=translate_x, f=translate_y)
@@ -357,6 +363,19 @@ def clip_border_segment(stream, style, width, side, border_box,
         return pi / 8 * (a + b) * (
             1 + 3 * x ** 2 / (10 + sqrt(4 - 3 * x ** 2)))
 
+    def draw_dash(cx, cy, width=0, height=0, r=0):
+        """Draw a single dash or dot centered on cx, cy."""
+        if style == 'dotted':
+            ratio = r / sqrt(pi)
+            stream.move_to(cx + r, cy)
+            stream.curve_to(cx + r, cy + ratio, cx + ratio, cy + r, cx, cy + r)
+            stream.curve_to(cx - ratio, cy + r, cx - r, cy + ratio, cx - r, cy)
+            stream.curve_to(cx - r, cy - ratio, cx - ratio, cy - r, cx, cy - r)
+            stream.curve_to(cx + ratio, cy - r, cx + r, cy - ratio, cx + r, cy)
+            stream.close()
+        elif style == 'dashed':
+            stream.rectangle(cx - width / 2, cy - height / 2, width, height)
+
     if side == 'top':
         (px1, py1), rounded1 = transition_point(tlh, tlv, bl, bt)
         (px2, py2), rounded2 = transition_point(-trh, trv, -br, bt)
@@ -407,25 +426,48 @@ def clip_border_segment(stream, style, width, side, border_box,
 
     if style in ('dotted', 'dashed'):
         dash = width if style == 'dotted' else 3 * width
+        stream.clip(even_odd=True)
+        stream.end()
         if rounded1 or rounded2:
-            # At least one of the two corners is rounded
+            # At least one of the two corners is rounded.
             chl1 = corner_half_length(a1, b1)
             chl2 = corner_half_length(a2, b2)
             length = line_length + chl1 + chl2
             dash_length = round(length / dash)
             if rounded1 and rounded2:
-                # 2x dashes
+                # 2x dashes.
                 dash = length / (dash_length + dash_length % 2)
             else:
-                # 2x - 1/2 dashes
+                # 2x - 1/2 dashes.
                 dash = length / (dash_length + dash_length % 2 - 0.5)
             dashes1 = ceil((chl1 - dash / 2) / dash)
             dashes2 = ceil((chl2 - dash / 2) / dash)
             line = floor(line_length / dash)
 
-            def draw_dots(dashes, line, way, x, y, px, py, chl):
-                if not dashes:
-                    return line + 1, 0
+            def draw_dashes(dashes, line, way, x, y, px, py, chl):
+                if style == 'dotted':
+                    if dashes == 0:
+                        return line + 1, -1
+                    elif dashes == 1:
+                        return line + 1, -0.5
+
+                    for i in range(1, dashes, 2):
+                        a = ((2 * angle - way) + i * way * dash / chl) / 4 * pi
+                        cx = x if side in ('top', 'bottom') else main_offset
+                        cy = y if side in ('left', 'right') else main_offset
+                        draw_dash(
+                            cx + px - (abs(px) - dash / 2) * cos(a),
+                            cy + py - (abs(py) - dash / 2) * sin(a),
+                            r=(dash / 2))
+                    next_a = ((2 * angle - way) + (i + 2) * way * dash / chl) / 4 * pi
+                    offset = next_a / pi * 2 - angle
+                    if dashes % 2:
+                        line += 1
+                    return line, offset
+
+                if dashes == 0:
+                    return line + 1, -1/3
+
                 for i in range(0, dashes, 2):
                     i += 0.5  # half dash
                     angle1 = (
@@ -458,42 +500,53 @@ def clip_border_segment(stream, style, width, side, border_box,
                         (angle * pi / 2 - angle2) / (angle2 - angle1))
                 return line, offset
 
-            line, offset = draw_dots(
-                dashes1, line, way, bbx, bby, px1, py1, chl1)
-            line = draw_dots(
+            line, offset = draw_dashes(dashes1, line, way, bbx, bby, px1, py1, chl1)
+            line = draw_dashes(
                 dashes2, line, -way, bbx + bbw, bby + bbh, px2, py2, chl2)[0]
 
             if line_length > 1e-6:
                 for i in range(0, line, 2):
                     i += offset
                     if side in ('top', 'bottom'):
-                        x1 = max(bbx + px1 + i * dash, bbx + px1)
-                        x2 = min(bbx + px1 + (i + 1) * dash, bbx + bbw + px2)
+                        x1 = bbx + px1 + i * dash
+                        x2 = bbx + px1 + (i + 1) * dash
                         y1 = main_offset - (width if way < 0 else 0)
                         y2 = y1 + width
                     elif side in ('left', 'right'):
-                        y1 = max(bby + py1 + i * dash, bby + py1)
-                        y2 = min(bby + py1 + (i + 1) * dash, bby + bbh + py2)
+                        y1 = bby + py1 + i * dash
+                        y2 = bby + py1 + (i + 1) * dash
                         x1 = main_offset - (width if way > 0 else 0)
                         x2 = x1 + width
-                    stream.rectangle(x1, y1, x2 - x1, y2 - y1)
+                    draw_dash(
+                        x1 + (x2 - x1) / 2, y1 + (y2 - y1) / 2,
+                        x2 - x1, y2 - y1, width / 2)
         else:
-            # 2x + 1 dashes
-            stream.clip(even_odd=True)
-            stream.end()
-            dash = length / (
-                round(length / dash) - (round(length / dash) + 1) % 2) or 1
-            for i in range(0, round(length / dash), 2):
+            # No rounded corner, dashes on corners and evenly spaced between.
+            number_of_spaces = floor(length / dash / 2)
+            number_of_dashes = number_of_spaces + 1
+            if style == 'dotted':
+                dash = width
+                if number_of_spaces:
+                    space = (length - number_of_dashes * dash) / number_of_spaces
+                else:
+                    space = 0  # no space, unused
+            elif style == 'dashed':
+                space = dash = length / (number_of_spaces + number_of_dashes) or 1
+            for i in range(0, number_of_dashes + 1):
+                advance = i * (space + dash)
                 if side == 'top':
-                    stream.rectangle(bbx + i * dash, bby, dash, width)
+                    cx, cy = bbx + advance + dash / 2, bby + width / 2
+                    dash_width, dash_height = dash, width
                 elif side == 'right':
-                    stream.rectangle(
-                        bbx + bbw - width, bby + i * dash, width, dash)
+                    cx, cy = bbx + bbw - width / 2, bby + advance + dash / 2
+                    dash_width, dash_height = width, dash
                 elif side == 'bottom':
-                    stream.rectangle(
-                        bbx + i * dash, bby + bbh - width, dash, width)
+                    cx, cy = bbx + advance + dash / 2, bby + bbh - width / 2
+                    dash_width, dash_height = dash, width
                 elif side == 'left':
-                    stream.rectangle(bbx, bby + i * dash, width, dash)
+                    cx, cy = bbx + width / 2, bby + advance + dash / 2
+                    dash_width, dash_height = width, dash
+                draw_dash(cx, cy, dash_width, dash_height, dash / 2)
     stream.clip(even_odd=True)
     stream.end()
 
@@ -551,14 +604,15 @@ def draw_rect_border(stream, box, widths, style, color):
 def draw_line(stream, x1, y1, x2, y2, thickness, style, color, offset=0):
     assert x1 == x2 or y1 == y2  # Only works for vertical or horizontal lines
 
-    with stacked(stream):
+    with stream.stacked():
         if style not in ('ridge', 'groove'):
             stream.set_color(color, stroke=True)
 
         if style == 'dashed':
             stream.set_dash([5 * thickness], offset)
         elif style == 'dotted':
-            stream.set_dash([thickness], offset)
+            stream.set_line_cap(1)
+            stream.set_dash([0, 2 * thickness], offset)
 
         if style == 'double':
             stream.set_line_width(thickness / 3)
@@ -627,7 +681,7 @@ def draw_outline(stream, box):
             box.border_width() + 2 * width + 2 * offset,
             box.border_height() + 2 * width + 2 * offset)
         for side in SIDES:
-            with stacked(stream):
+            with stream.artifact(), stream.stacked():
                 clip_border_segment(stream, style, width, side, outline_box)
                 draw_rect_border(
                     stream, outline_box, 4 * (width,), style,

weasyprint/draw/text.py

@@ -12,7 +12,6 @@ from ..text.fonts import get_hb_object_data
 from ..text.line_break import get_last_word_end
 from .border import draw_line
 from .color import get_color
-from .stack import stacked
 
 
 def draw_text(stream, textbox, offset_x, text_overflow, block_ellipsis):
@@ -78,7 +77,7 @@ def draw_text(stream, textbox, offset_x, text_overflow, block_ellipsis):
 def draw_emojis(stream, font_size, x, y, emojis):
     """Draw list of emojis."""
     for image, font, a, d, e, f in emojis:
-        with stacked(stream):
+        with stream.stacked():
             stream.transform(a=a, d=d, e=x + e * font_size, f=y + f)
             image.draw(stream, font_size, font_size, None)
 

weasyprint/formatting_structure/boxes.py

@@ -72,6 +72,7 @@ class Box:
     is_for_root_element = False
     is_column = False
     is_leader = False
+    is_outside_marker = False
 
     # Other properties
     transformation_matrix = None
@@ -80,6 +81,8 @@ class Box:
     footnote = None
     cached_counter_values = None
     missing_link = None
+    link_annotation = None
+    force_fragmentation = False
 
     # Default, overriden on some subclasses
     def all_children(self):
@@ -502,8 +505,6 @@ class InlineBox(InlineLevelBox, ParentBox):
     inline box.
 
     """
-    link_annotation = None
-
     def hit_area(self):
         """Return the (x, y, w, h) rectangle where the box is clickable."""
         # Use line-height (margin_height) rather than border_height

weasyprint/formatting_structure/build.py

@@ -195,9 +195,10 @@ def element_to_box(element, style_for, get_image_from_uri, base_url,
             footnote = child_boxes[0]
             footnote.style['float'] = 'none'
             footnotes.append(footnote)
-            call_style = style_for(element, 'footnote-call')
+            call_style = style_for(footnote.element, 'footnote-call')
             footnote_call = make_box(
-                f'{element.tag}::footnote-call', call_style, [], element)
+                f'{footnote.element.tag}::footnote-call', call_style, [],
+                footnote.element)
             footnote_call.children = content_to_boxes(
                 call_style, footnote_call, quote_depth, counter_values,
                 get_image_from_uri, target_collector, counter_style)
@@ -250,7 +251,7 @@ def element_to_box(element, style_for, get_image_from_uri, base_url,
         marker = make_box(
             f'{element.tag}::footnote-marker', marker_style, [], element)
         marker.children = content_to_boxes(
-            marker_style, box, quote_depth, counter_values, get_image_from_uri,
+            marker_style, marker, quote_depth, counter_values, get_image_from_uri,
             target_collector, counter_style)
         box.children.insert(0, marker)
 
@@ -344,7 +345,6 @@ def marker_to_box(element, state, parent_style, style_for, get_image_from_uri,
         if not children and style['list_style_type'] != 'none':
             counter_value = counter_values.get('list-item', [0])[-1]
             counter_type = style['list_style_type']
-            # TODO: rtl numbered list has the dot on the left
             if marker_text := counter_style.render_marker(counter_type, counter_value):
                 box = boxes.TextBox.anonymous_from(box, marker_text)
                 box.style['white_space'] = 'pre-wrap'
@@ -358,13 +358,7 @@ def marker_to_box(element, state, parent_style, style_for, get_image_from_uri,
         # We can safely edit everything that can't be changed by user style
         # See https://drafts.csswg.org/css-pseudo-4/#marker-pseudo
         marker_box.style['position'] = 'absolute'
-        if parent_style['direction'] == 'ltr':
-            translate_x = properties.Dimension(-100, '%')
-        else:
-            translate_x = properties.Dimension(100, '%')
-        translate_y = properties.ZERO_PIXELS
-        marker_box.style['transform'] = (
-            ('translate', (translate_x, translate_y)),)
+        marker_box.is_outside_marker = True
     else:
         marker_box = boxes.InlineBox.anonymous_from(box, children)
     yield marker_box
@@ -421,7 +415,7 @@ def compute_content_list(content_list, parent_box, counter_values, css_token,
         elif type_ == 'url' and get_image_from_uri is not None:
             origin, uri = value
             if origin != 'external':
-                # Embedding internal references is impossible
+                # Embedding internal references is impossible.
                 continue
             image = get_image_from_uri(
                 url=uri, orientation=parent_box.style['image_orientation'])
@@ -431,12 +425,12 @@ def compute_content_list(content_list, parent_box, counter_values, css_token,
         elif type_ == 'content()':
             added_text = extract_text(value, parent_box)
             # Simulate the step of white space processing
-            # (normally done during the layout)
+            # (normally done during the layout).
             add_text(added_text.strip())
         elif type_ == 'string()':
             if not in_page_context:
-                # string() is currently only valid in @page context
-                # See https://github.com/Kozea/WeasyPrint/issues/723
+                # string() is currently only valid in @page context.
+                # See issue #723.
                 LOGGER.warning(
                     '"string(%s)" is only allowed in page margins',
                     ' '.join(value))
@@ -810,9 +804,9 @@ def table_boxes_children(box, children):
     children = [
         child
         for prev_child, child, next_child in zip(
-            [None] + children[:-1],
+            [None, *children[:-1]],
             children,
-            children[1:] + [None]
+            [*children[1:], None]
         )
         if not (
             # Ignore some whitespace: rule 1.4
@@ -990,6 +984,25 @@ def wrap_table(box, children):
     return wrapper
 
 
+def blockify(box, layout):
+    """Turn an inline box into a block box."""
+    # See https://drafts.csswg.org/css-display-4/#blockify.
+    if isinstance(box, boxes.InlineBlockBox):
+        anonymous = boxes.BlockBox.anonymous_from(box, box.children)
+    elif isinstance(box, boxes.InlineReplacedBox):
+        replacement = box.replacement
+        anonymous = boxes.BlockReplacedBox.anonymous_from(box, replacement)
+    elif isinstance(box, boxes.InlineLevelBox):
+        anonymous = boxes.BlockBox.anonymous_from(box, [box])
+        setattr(box, f'is_{layout}_item', False)
+    else:
+        return box
+    anonymous.style = box.style
+    setattr(anonymous, f'is_{layout}_item', True)
+    return anonymous
+
+
+
 def flex_boxes(box):
     """Remove and add boxes according to the flex model.
 
@@ -1019,18 +1032,7 @@ def flex_children(box, children):
                 # affected by the white-space property"
                 # https://www.w3.org/TR/css-flexbox-1/#flex-items
                 continue
-            if isinstance(child, boxes.InlineBlockBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, child.children)
-                anonymous.style = child.style
-                anonymous.is_flex_item = True
-                flex_children.append(anonymous)
-            elif isinstance(child, boxes.InlineLevelBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, [child])
-                anonymous.style = child.style
-                anonymous.is_flex_item = True
-                flex_children.append(anonymous)
-            else:
-                flex_children.append(child)
+            flex_children.append(blockify(child, 'flex'))
         return flex_children
     else:
         return children
@@ -1064,19 +1066,7 @@ def grid_children(box, children):
                 # affected by the white-space property"
                 # https://drafts.csswg.org/css-grid-2/#grid-item
                 continue
-            if isinstance(child, boxes.InlineBlockBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, child.children)
-                anonymous.style = child.style
-                anonymous.is_grid_item = True
-                grid_children.append(anonymous)
-            elif isinstance(child, boxes.InlineLevelBox):
-                anonymous = boxes.BlockBox.anonymous_from(child, [child])
-                anonymous.style = child.style
-                child.is_grid_item = False
-                anonymous.is_grid_item = True
-                grid_children.append(anonymous)
-            else:
-                grid_children.append(child)
+            grid_children.append(blockify(child, 'grid'))
         return grid_children
     else:
         return children

weasyprint/images.py

@@ -8,8 +8,6 @@ from io import BytesIO
 from itertools import cycle
 from math import inf
 from pathlib import Path
-from urllib.parse import urlparse
-from urllib.request import url2pathname
 from xml.etree import ElementTree
 
 import pydyf
@@ -70,7 +68,7 @@ class RasterImage:
 
         # The presence of the APP14 segment indicates an Adobe image with
         # inverted CMYK data. Specify a Decode Array to invert it again back to
-        # normal. See https://github.com/Kozea/WeasyPrint/pull/2179.
+        # normal. See PR #2179.
         app14 = getattr(original_pillow_image, 'app', {}).get('APP14')
         self.invert_colors = self.mode == 'CMYK' and app14 is not None
 
@@ -299,11 +297,6 @@ def get_image_from_uri(cache, url_fetcher, options, url, forced_mime_type=None,
 
     try:
         with fetch(url_fetcher, url) as result:
-            parsed_url = urlparse(result.get('redirected_url'))
-            if parsed_url.scheme == 'file':
-                filename = url2pathname(parsed_url.path)
-            else:
-                filename = None
             if 'string' in result:
                 string = result['string']
             else:
@@ -337,9 +330,9 @@ def get_image_from_uri(cache, url_fetcher, options, url, forced_mime_type=None,
             else:
                 # Store image id to enable cache in Stream.add_image
                 image_id = md5(url.encode(), usedforsecurity=False).hexdigest()
+                path = result.get('path')
                 image = RasterImage(
-                    pillow_image, image_id, string, filename, cache,
-                    orientation, options)
+                    pillow_image, image_id, string, path, cache, orientation, options)
 
     except (URLFetchingError, ImageLoadingError) as exception:
         LOGGER.error('Failed to load image at %r: %s', url, exception)
@@ -733,8 +726,8 @@ class RadialGradient(Gradient):
                         intermediate_color = gradient_average_color(
                             [previous_color, previous_color, color, color],
                             [previous_position, 0, 0, position])
-                        colors = [intermediate_color] + colors[i:]
-                        positions = [0] + positions[i:]
+                        colors = [intermediate_color, *colors[i:]]
+                        positions = [0, *positions[i:]]
                         break
         first, last, positions = normalize_stop_positions(positions)
 
@@ -775,7 +768,7 @@ class RadialGradient(Gradient):
             colors *= repeat
             positions = [
                 i + position for i in range(repeat) for position in positions]
-            points = points[:5] + (points[5] + gradient_length * repeat_after,)
+            points = (*points[:5], points[5] + gradient_length * repeat_after)
 
         if points[2] == 0:
             # Inner circle has 0 radius, no need to repeat inside, return
@@ -785,7 +778,7 @@ class RadialGradient(Gradient):
         repeat_before = points[2] / gradient_length
 
         # Set the inner circle size to 0
-        points = points[:2] + (0,) + points[3:]
+        points = (*points[:2], 0, *points[3:])
 
         # Find how many times the whole gradient can be repeated
         full_repeat = int(repeat_before)
@@ -830,7 +823,7 @@ class RadialGradient(Gradient):
                 average_positions = [position, ratio, ratio, next_position]
                 zero_color = gradient_average_color(
                     average_colors, average_positions)
-                colors = [zero_color] + original_colors[-(i - 1):] + colors
+                colors = [zero_color, *original_colors[-(i - 1):], *colors]
                 new_positions = [
                     position - 1 - full_repeat for position
                     in original_positions[-(i - 1):]]

weasyprint/layout/__init__.py

@@ -389,10 +389,13 @@ class LayoutContext:
             if not self.in_column:
                 self.page_bottom -= footnote_area.margin_height()
             last_child = footnote_area.children[-1]
-            overflow = (
-                last_child.position_y + last_child.margin_height() >
+            last_child_bottom = (
+                last_child.position_y + last_child.margin_height() -
+                last_child.margin_bottom)
+            footnote_area_bottom = (
                 footnote_area.position_y + footnote_area.margin_height() -
                 footnote_area.margin_bottom)
+            overflow = last_child_bottom > footnote_area_bottom
             return overflow
         else:
             self.current_footnote_area.height = 0

weasyprint/layout/absolute.py

@@ -67,7 +67,9 @@ def absolute_width(box, context, cb_x, cb_y, cb_width, cb_height):
         available_width = cb_width - (
             paddings_borders + box.margin_left + box.margin_right)
         box.width = shrink_to_fit(context, box, available_width)
-        if not ltr:
+        if box.is_outside_marker:
+            translate_box_width = ltr
+        elif not ltr:
             translate_box_width = True
             translate_x = default_translate_x + available_width
     elif box.left != 'auto' and box.right != 'auto' and box.width != 'auto':
@@ -268,6 +270,7 @@ def absolute_box_layout(context, box, containing_block, fixed_boxes,
             context, box, containing_block, fixed_boxes, bottom_space,
             skip_stack, cb_x, cb_y, cb_width, cb_height)
     context.finish_block_formatting_context(new_box)
+
     return new_box, resume_at